1
00:00:05,440 --> 00:00:09,341
Hi welcome to this new lesson, so
we are here in the final video,

2
00:00:09,341 --> 00:00:14,258
this has been a five part video of this
final project where we're actually really

3
00:00:14,258 --> 00:00:17,440
putting together everything
that we've learned so

4
00:00:17,440 --> 00:00:21,854
far in terms of data structures and
object oriented programming.

5
00:00:21,854 --> 00:00:27,249
To craft the behavior of a lank transient
in an object-oriented structure,

6
00:00:27,249 --> 00:00:30,569
we've written the Langston's hand already,

7
00:00:30,569 --> 00:00:34,104
we're rewriting it in
an object-oriented way.

8
00:00:34,104 --> 00:00:38,534
And we think that really looking at
these two, how do you convert a script

9
00:00:38,534 --> 00:00:42,456
like that into an object-oriented
script using two classes and

10
00:00:42,456 --> 00:00:46,184
how those kind of relate and
dialogue with one another.

11
00:00:46,184 --> 00:00:51,623
It's kind of an interesting challenge for
the conclusion of this course, so let's

12
00:00:51,623 --> 00:00:57,714
just jump back into the project and see
how we can actually conclude this lesson.

13
00:00:57,714 --> 00:01:02,070
So this is where we left off,
let's just run to see,

14
00:01:02,070 --> 00:01:06,624
we have two ants that if we
look into our main script, so

15
00:01:06,624 --> 00:01:11,378
we have an instance of a grid and
two instances of two, and

16
00:01:11,378 --> 00:01:14,482
we can actually have more of those.

17
00:01:14,482 --> 00:01:19,966
We can actually do ten, any number of,
and at this point, and in the setup,

18
00:01:19,966 --> 00:01:25,174
we only are calling for the initialization
of the random data, right?

19
00:01:25,174 --> 00:01:30,308
That the grid can actually start with
random data, and then in the draw,

20
00:01:30,308 --> 00:01:35,414
we actually only execute one function
of the ands and the grid, right?

21
00:01:35,414 --> 00:01:40,357
So we're using an outline style of
functions, which is the run function for

22
00:01:40,357 --> 00:01:43,370
all of them contains
the series of functions or

23
00:01:43,370 --> 00:01:47,094
methods in a way that we
are going to be executing.

24
00:01:47,094 --> 00:01:51,569
So let's go back, this is the grid
class that we've been writing, and

25
00:01:51,569 --> 00:01:54,750
this is the ant class
that we've been writing.

26
00:01:54,750 --> 00:02:00,691
And here, one small detail,
I actually moved the stay within bounds,

27
00:02:00,691 --> 00:02:03,166
if you look at the last video,

28
00:02:03,166 --> 00:02:08,126
I originally had stay within
bounds within the behavior.

29
00:02:08,126 --> 00:02:13,391
I'm actually keeping it in the run so,
as we had outlined originally,

30
00:02:13,391 --> 00:02:17,867
our ant's run function will
contain the display of the ant,

31
00:02:17,867 --> 00:02:21,414
the ants behavior, and stay within bounds.

32
00:02:21,414 --> 00:02:25,516
So we have all the pieces, the only
bit that we're going to be working on

33
00:02:25,516 --> 00:02:28,698
right now is the ant behavior,
which we are using it as

34
00:02:28,698 --> 00:02:32,820
a placeholder currently with this
move forward function, right.

35
00:02:32,820 --> 00:02:39,024
As you know, the Langton ant algorithm
actually changes behavior and

36
00:02:39,024 --> 00:02:46,484
movement based on the data of the grid,
so this was a placeholder, right.

37
00:02:46,484 --> 00:02:50,153
But we can actually leave it there for
a moment,

38
00:02:50,153 --> 00:02:55,013
let's just write what we want to do,
so we want to check first,

39
00:02:55,013 --> 00:02:58,527
if the cell is white, do something, right?

40
00:02:58,527 --> 00:03:06,154
If the cell is black,
do something else, right?

41
00:03:06,154 --> 00:03:14,290
So let's just start with the if
self dot grid object, right?

42
00:03:14,290 --> 00:03:19,991
The way we have access to the grid,
as we've seen in past videos,

43
00:03:19,991 --> 00:03:26,316
is by this grid reference object, and
here we would need to get the data,

44
00:03:26,316 --> 00:03:31,474
we actually want to access
the data by the index, right?

45
00:03:31,474 --> 00:03:35,065
So if we look into the,

46
00:03:35,065 --> 00:03:40,548
we actually have a function that,

47
00:03:40,548 --> 00:03:47,165
this function here to get data function,

48
00:03:47,165 --> 00:03:52,270
it will give us the coordinate,

49
00:03:52,270 --> 00:03:59,643
just to be more precise,
if we provide the x and

50
00:03:59,643 --> 00:04:05,505
y index is going to give us the real world

51
00:04:05,505 --> 00:04:10,672
coordinate for this function.

52
00:04:10,672 --> 00:04:14,386
So we need something else,

53
00:04:14,386 --> 00:04:20,203
let's call this define get data by index,

54
00:04:21,317 --> 00:04:26,608
And here we're going to use self,

55
00:04:26,608 --> 00:04:32,264
and just to be clear that we are giving

56
00:04:32,264 --> 00:04:38,473
the index x index comma y index, right?

57
00:04:38,473 --> 00:04:44,599
And then the index, Its

58
00:04:44,599 --> 00:04:49,549
going to be x x

59
00:04:49,549 --> 00:04:55,049
index plus y

60
00:04:55,049 --> 00:05:00,549
index times

61
00:05:00,549 --> 00:05:04,399
self dot

62
00:05:04,399 --> 00:05:09,355
columns.

63
00:05:11,497 --> 00:05:13,500
And finally we can return.

64
00:05:22,603 --> 00:05:27,516
So we're doing basically
a similar thing than before,

65
00:05:27,516 --> 00:05:32,429
before we're actually taking
in consideration a world

66
00:05:32,429 --> 00:05:37,514
coordinate because we had to
divide that by the height.

67
00:05:37,514 --> 00:05:42,715
In this case, we could actually do
this calculation in a simpler fashion,

68
00:05:42,715 --> 00:05:48,078
what we're actually trying to do is
saying, hey, if I provide you an index,

69
00:05:48,078 --> 00:05:53,594
would you give me the data that is
contained within that index, right?

70
00:05:53,594 --> 00:06:00,497
And that's what, this is the function that
we actually need at this point in the,

71
00:06:00,497 --> 00:06:07,066
and let's just jump into the, and,
and here use this new function, right?

72
00:06:07,066 --> 00:06:10,914
This function didn't exist, but

73
00:06:10,914 --> 00:06:15,822
it's going to be now
easier to access that data

74
00:06:15,822 --> 00:06:21,374
if we provide now self x comma self y,
right?

75
00:06:21,374 --> 00:06:25,031
And we're going to say if
that is equals to one,

76
00:06:25,031 --> 00:06:29,582
which is equivalent to white,
do something, right?

77
00:06:29,582 --> 00:06:35,318
What do we want to do,
we want to rotate clockwise.

78
00:06:38,674 --> 00:06:42,490
And I'm doing this as a comment because
we don't have these functions yet, right?

79
00:06:44,161 --> 00:06:51,695
We want to flip data and,
then we want to move forward.

80
00:06:54,146 --> 00:06:59,681
And in the case,
let's just do an Elif statement,

81
00:06:59,681 --> 00:07:02,401
in the case it's black.

82
00:07:05,338 --> 00:07:12,161
So elif, in the case,
the same calculation returns a number,

83
00:07:12,161 --> 00:07:17,457
sorry, a number, zero,
my bad there, right?

84
00:07:19,617 --> 00:07:27,018
What we want to do here is
rotate counterclockwise,

85
00:07:35,387 --> 00:07:40,750
Flip the data, what I mean by
flipping data is like, if it's black,

86
00:07:40,750 --> 00:07:45,566
turn it white, if it's white,
turn it, and so on, right?

87
00:07:45,566 --> 00:07:52,189
And move forward, Right, so let's

88
00:07:52,189 --> 00:07:55,866
just organize this a little bit, this is
kind of an outline of what we're doing.

89
00:08:02,934 --> 00:08:03,718
The move forward.

90
00:08:03,718 --> 00:08:07,672
Forward function we actually do have,
right, so this we don't need anymore.

91
00:08:09,292 --> 00:08:10,568
Let's cut this so

92
00:08:10,568 --> 00:08:16,572
we can actually replace the move forward
with the pieces that we actually do have.

93
00:08:16,572 --> 00:08:19,068
In both cases,
the move forward happens, right?

94
00:08:19,068 --> 00:08:21,628
So now we have an outline
of what it's missing.

95
00:08:21,628 --> 00:08:25,925
And this is what we're going to
write right now, right?

96
00:08:25,925 --> 00:08:31,132
So we need the, let's just first,
just for good measure, right.

97
00:08:33,512 --> 00:08:37,408
I'm going to save this and
then make sure that we're running.

98
00:08:37,408 --> 00:08:43,608
So we are running into an error,
because we added a bunch of new code.

99
00:08:43,608 --> 00:08:48,032
I think we're running into a missing
of a parenthesis somewhere here, right?

100
00:08:48,032 --> 00:08:50,440
Is that what we started there?

101
00:08:50,440 --> 00:08:56,412
And then we are actually missing
here as well, let's see.

102
00:08:56,412 --> 00:08:58,668
Okay, so here we are, yet again.

103
00:08:58,668 --> 00:09:00,932
Everything is running, okay, that's good.

104
00:09:00,932 --> 00:09:02,752
So let's just write the function.

105
00:09:04,732 --> 00:09:08,869
We've written these functions already,
so if you want to go and find them or

106
00:09:08,869 --> 00:09:12,156
copy paste them from your past video,
we can do so as well.

107
00:09:12,156 --> 00:09:18,412
So defined, rotate clockwise.

108
00:09:18,412 --> 00:09:24,343
And I'm going to do 90 because,
just to make sure that we giving evidence

109
00:09:24,343 --> 00:09:30,956
that we're doing a 90 degree rotation,
right, it's not really important,

110
00:09:30,956 --> 00:09:35,902
but I like kind of keeping track
of how we're doing things.

111
00:09:35,902 --> 00:09:41,587
So if self.dir

112
00:09:41,587 --> 00:09:46,833
== 0, then

113
00:09:46,833 --> 00:09:53,576
self.dir = 1.

114
00:09:53,576 --> 00:09:56,657
Right, and that's our rotation, right?

115
00:09:56,657 --> 00:10:04,113
We're just flipping an integer from 0 to
1, assuming that 0 means to the right,

116
00:10:04,113 --> 00:10:09,238
1 is facing down, 2 is facing left,
and so on, right?

117
00:10:09,238 --> 00:10:13,817
So we can do this with
a series of elif statements.

118
00:10:18,682 --> 00:10:21,458
So elif, now we go to the next one, right?

119
00:10:21,458 --> 00:10:25,942
So if the direction is 1, we move to 2.

120
00:10:27,562 --> 00:10:31,382
Let's just do two more between.

121
00:10:33,642 --> 00:10:39,506
If the direction is 2 becomes 3,

122
00:10:39,506 --> 00:10:42,222
3 becomes 0.

123
00:10:42,222 --> 00:10:43,742
We go back to the first one.

124
00:10:43,742 --> 00:10:48,382
Make sure to do an elif statement as
opposed to a series of if statements.

125
00:10:48,382 --> 00:10:50,449
If you make a series of if statements,

126
00:10:50,449 --> 00:10:54,254
you're going to execute the first
condition, that's going to be true.

127
00:10:54,254 --> 00:10:56,450
The second condition
that's going to be true,

128
00:10:56,450 --> 00:10:59,982
you're going to basically return
to where you started, right?

129
00:10:59,982 --> 00:11:05,930
So this is the clockwise
rotation function.

130
00:11:05,930 --> 00:11:10,919
I'm sure you can find
beautiful ways of writing

131
00:11:10,919 --> 00:11:16,155
it way shorter than this chunk,
but I invite you to

132
00:11:16,155 --> 00:11:21,393
consider that I'm going to
add a new function here,

133
00:11:21,393 --> 00:11:26,010
which is counterclockwise 90, right?

134
00:11:26,010 --> 00:11:32,022
So if you go from 0,
you're going to get 3.

135
00:11:32,022 --> 00:11:38,062
If you go from 1, you will get back to 0.

136
00:11:38,062 --> 00:11:42,038
If you have 2,
you're going to end up with a 1, and

137
00:11:42,038 --> 00:11:46,792
if you have a 3,
you're going to end up with that 2, right?

138
00:11:46,792 --> 00:11:51,762
So we have now the counterclockwise and
the clockwise rotations.

139
00:11:53,742 --> 00:11:57,122
So let's just replace this.

140
00:11:57,122 --> 00:12:05,660
So with self.rotate clockwise and,

141
00:12:09,396 --> 00:12:19,279
self.rotate counterclockwise, right?

142
00:12:19,279 --> 00:12:23,208
So that's good.

143
00:12:23,208 --> 00:12:25,504
I think that the only thing that
we're missing is flipping the data.

144
00:12:25,504 --> 00:12:29,652
Let's see if we're running
into errors here, we are.

145
00:12:31,472 --> 00:12:35,016
Yeah, so I think we were having
just a small indentation issue.

146
00:12:35,016 --> 00:12:39,444
I just kind of cut and paste
the functions a little bit to kind of,

147
00:12:39,444 --> 00:12:43,708
there was no kind of syntax error,
but I think we're having,

148
00:12:43,708 --> 00:12:47,808
I couldn't find quite quickly
the indentation issue, but

149
00:12:47,808 --> 00:12:52,424
just by copy and pasting the function,
that kind of resolved it.

150
00:12:52,424 --> 00:12:54,608
So now we have the behavior of the ant.

151
00:12:54,608 --> 00:13:01,312
As you can see here, we have the rotate
clockwise when they're in white cell and

152
00:13:01,312 --> 00:13:06,332
rotate counterclockwise when
they're in the black cell.

153
00:13:07,672 --> 00:13:14,913
So basically the only information that we
are needing is a new flip the data, right?

154
00:13:14,913 --> 00:13:19,321
And for this we actually will create
a final function which is going to be

155
00:13:19,321 --> 00:13:22,372
a handy function for altering the data.

156
00:13:22,372 --> 00:13:27,537
And we basically can do a function
that is basically allows us

157
00:13:27,537 --> 00:13:32,852
to manipulate, we're going to
call this set data by index.

158
00:13:32,852 --> 00:13:37,712
So set_data_by_index.

159
00:13:39,362 --> 00:13:44,369
And this set_data_ by_index function

160
00:13:44,369 --> 00:13:48,803
will take an x_index coordinate and

161
00:13:48,803 --> 00:13:53,245
the y_index and the value, right?

162
00:13:53,245 --> 00:13:58,742
So we're going to say, hey,
what value do you want to provide here?

163
00:14:00,042 --> 00:14:03,168
So the index, as we have seen before,

164
00:14:03,168 --> 00:14:08,361
we will use the same index
calculation that we've done so far.

165
00:14:14,262 --> 00:14:21,362
There we go,
the index calculation and the data.

166
00:14:22,422 --> 00:14:26,254
Instead of returning,
we're going to just assign the data.

167
00:14:26,254 --> 00:14:31,446
So self.data with that index,

168
00:14:31,446 --> 00:14:38,802
it's going to be changed to the value,
right?

169
00:14:38,802 --> 00:14:43,155
So this function here, this is
a helper function for the grid class,

170
00:14:43,155 --> 00:14:47,562
which is saying, hey,
if you are in index, let's say 5,5.

171
00:14:47,562 --> 00:14:52,445
And you want to switch that value
to a value of 1 or 2, right?

172
00:14:52,445 --> 00:14:54,242
Sorry, 0 or 1.

173
00:14:54,242 --> 00:15:00,732
Just give me the value you want,
the grid will assign it to the cell.

174
00:15:02,392 --> 00:15:07,321
Probably what you want to do at this point
is just make sure that your data validate

175
00:15:07,321 --> 00:15:09,869
that data in some way or another, right?

176
00:15:09,869 --> 00:15:15,442
Making sure that if it's a value
outside the bounds of 0 and

177
00:15:15,442 --> 00:15:18,795
1, you cap it to 0 and 1, right?

178
00:15:18,795 --> 00:15:24,002
But besides the scope of this class,
what we're hoping is that

179
00:15:24,002 --> 00:15:29,408
we have a way of communicating,
sending information from the and

180
00:15:29,408 --> 00:15:33,846
to the grid saying, hey,
I'm here, I'm moving.

181
00:15:33,846 --> 00:15:38,342
I actually want to change the data
where I just, where I have been.

182
00:15:38,342 --> 00:15:40,977
And this is going to be the function
that's going to allow us to do

183
00:15:40,977 --> 00:15:41,806
that, right?

184
00:15:41,806 --> 00:15:49,041
So let's just go back to our ant class and
instead of flipping the data,

185
00:15:49,041 --> 00:15:53,261
which was a placeholder comment on that,

186
00:15:53,261 --> 00:15:59,051
let's do self.grid_object,
right, as you can see,

187
00:15:59,051 --> 00:16:03,786
we're using this grid object quite a bit.

188
00:16:03,786 --> 00:16:08,223
This reference set data by index,
which is a function that we just wrote.

189
00:16:08,223 --> 00:16:14,463
And the value is going to be self.x,
self.y,

190
00:16:14,463 --> 00:16:21,537
which are the index coordinates of the and
0 here.

191
00:16:21,537 --> 00:16:25,730
Because if we are in a white cell,
we want to provide a value of 0.

192
00:16:25,730 --> 00:16:30,455
We are assigning to this cell,
we're switching its value to 0.

193
00:16:30,455 --> 00:16:33,599
And if it's 0, we're going to switch it,
we're going to do the same thing.

194
00:16:33,599 --> 00:16:41,912
But 2y is on a value of 1, right?

195
00:16:41,912 --> 00:16:45,913
Because, remember that this function
set_data requires the x and

196
00:16:45,913 --> 00:16:50,135
y coordinates plus the value of
the cell that we want to assign, right?

197
00:16:50,135 --> 00:16:54,379
So, black cell will become white and
the white will become black.

198
00:16:54,379 --> 00:17:01,830
So I think we have it, let's see if
we don't run into any errors again.

199
00:17:01,830 --> 00:17:04,048
Yeah, there we go,
we have it running, right?

200
00:17:04,048 --> 00:17:05,793
So, what's going on?

201
00:17:05,793 --> 00:17:10,761
We have, as we've done before,
a Langton Zen algorithm that is

202
00:17:10,761 --> 00:17:14,809
actually moving based on
the grid it's working on,

203
00:17:14,809 --> 00:17:19,048
but at the same time it's
changing that grid, right?

204
00:17:19,048 --> 00:17:21,594
So by changing that grid,
there's a pattern emerging.

205
00:17:21,594 --> 00:17:23,288
There's a kind of a pattern
of behavior emerging.

206
00:17:23,288 --> 00:17:26,841
And in this case, we actually have
two ants, so we only have one.

207
00:17:26,841 --> 00:17:31,076
And so, this is what we
actually call complex_system,

208
00:17:31,076 --> 00:17:34,439
one system that actually has interactions.

209
00:17:34,439 --> 00:17:39,655
There's a very interesting interaction
between the ants and the grid.

210
00:17:39,655 --> 00:17:44,407
The grid becomes the canvas for affecting
the behavior of other entities, right?

211
00:17:44,407 --> 00:17:49,493
This is at the foundation of many
algorithms, such as Stigmergic,

212
00:17:49,493 --> 00:17:53,877
which is used for
simulating the behavior of actual ants.

213
00:17:53,877 --> 00:17:59,518
Ants, as they move around,
they leave a trace of a phenomenon,

214
00:17:59,518 --> 00:18:06,417
and that is actually being picked up by
other ants to actually optimize paths.

215
00:18:06,417 --> 00:18:12,504
So simulations of such systems use, or
might be using a system like this one,

216
00:18:12,504 --> 00:18:17,469
where you're actually leaving
behind information in a grid,

217
00:18:17,469 --> 00:18:21,511
and that could actually
be dissipating over time.

218
00:18:21,511 --> 00:18:23,398
Let's just do a small variations.

219
00:18:23,398 --> 00:18:24,984
Let's see a few things.

220
00:18:24,984 --> 00:18:28,539
What if we actually run
this with larger grid?

221
00:18:28,539 --> 00:18:33,396
So, something like 80 and 40?

222
00:18:33,396 --> 00:18:36,556
Again, our ants should
be able to handle that,

223
00:18:36,556 --> 00:18:39,640
like our system should
be able to handle that.

224
00:18:39,640 --> 00:18:44,367
The other thing that I would
like to test with you is

225
00:18:44,367 --> 00:18:48,655
an invitation to how we
initiated data here.

226
00:18:48,655 --> 00:18:55,614
What I like doing, if we go into the grid,
we could actually say, the init_data.

227
00:18:55,614 --> 00:18:59,003
Let's just create a variation of this,
right?

228
00:18:59,003 --> 00:19:02,616
Let's just copy paste this somewhere here.

229
00:19:04,938 --> 00:19:06,464
And I'm going to do a version of that.

230
00:19:06,464 --> 00:19:10,524
This is showing you maybe how you can
actually start designing with this.

231
00:19:10,524 --> 00:19:15,213
So, init_data_2, and
instead of doing a random number,

232
00:19:15,213 --> 00:19:20,366
we're going to say, hey,
everyone starts with a number 1, right?

233
00:19:20,366 --> 00:19:26,503
So instead of doing a random value,
everybody starts with a white cell, right?

234
00:19:26,503 --> 00:19:34,253
So once, instead of calling init_data_1,
How did we call it?

235
00:19:34,253 --> 00:19:36,314
Init_data_2, yeah.

236
00:19:36,314 --> 00:19:39,662
So we can actually swap to
this different function.

237
00:19:39,662 --> 00:19:44,937
So we're leaving behind the random,
but you can see we can actually start

238
00:19:44,937 --> 00:19:49,955
with a completely white canvas and
that makes it quite more visible for

239
00:19:49,955 --> 00:19:53,634
the ant's pattern of behavior to emerge,
right?

240
00:19:53,634 --> 00:19:58,239
So feel free not to necessarily
start with a random canvas,

241
00:19:58,239 --> 00:20:04,241
you can start with a white canvas or
a black canvas or half white, half black.

242
00:20:04,241 --> 00:20:06,882
You can create a function for that.

243
00:20:06,882 --> 00:20:09,828
I'm really curious to see
what you will do with this.

244
00:20:09,828 --> 00:20:15,908
Finally, and again, the invitation
with object-oriented programming,

245
00:20:15,908 --> 00:20:18,347
I'm going to create a third ant.

246
00:20:18,347 --> 00:20:21,830
And I know that this is a very
manual way of doing it,

247
00:20:21,830 --> 00:20:26,218
you can actually do it, as we've seen,
to do this in a for loop.

248
00:20:26,218 --> 00:20:31,051
But I think that fortix, I'm going to
leave that more in your hands.

249
00:20:31,051 --> 00:20:36,715
I'm going to just put a 30 and

250
00:20:36,715 --> 00:20:41,201
maybe a 20, right?

251
00:20:41,201 --> 00:20:46,939
And the direction doesn't matter at this
point, the direction and, Ant3.run().

252
00:20:53,005 --> 00:20:57,173
And you can see we actually have three
instances of these ants all operating

253
00:20:57,173 --> 00:20:58,509
under the same canvas.

254
00:20:58,509 --> 00:21:05,171
So, just to wrap up,
this has been a five videos series.

255
00:21:05,171 --> 00:21:10,689
It's a final project that we're
concluding, a data structures section.

256
00:21:10,689 --> 00:21:15,041
We're looking at how different data
structures, such as in this case the grid,

257
00:21:15,041 --> 00:21:19,137
and also how we're actually using
object-oriented programming to create

258
00:21:19,137 --> 00:21:22,214
simulations that have
relationships with one another.

259
00:21:22,214 --> 00:21:26,202
The ants are talking to one
another through the grid and

260
00:21:26,202 --> 00:21:32,028
the grid becomes really the canvas for
some data to be stored and passed around.

261
00:21:32,028 --> 00:21:36,891
Yeah, when I started programming, these
kind of simulations were mesmerizing and

262
00:21:36,891 --> 00:21:39,288
really interesting to be curious about,

263
00:21:39,288 --> 00:21:43,544
what else could you do with coding and
using these techniques for design?

264
00:21:43,544 --> 00:21:48,565
So we invite you to share with
us all the design variations and

265
00:21:48,565 --> 00:21:54,481
permutations that you might be doing
as you learn how to code yourself.

266
00:21:54,481 --> 00:21:56,872
So, thank you for staying with us, and

267
00:21:56,872 --> 00:21:59,634
I'll see you in
the conclusion of the class.

268
00:21:59,634 --> 00:22:00,134
Bye.