WEBVTT
Kind: captions
Language: en

00:00:00.000 --> 00:00:02.690 align:start position:0%
 
this<00:00:00.510><c> talk</c><00:00:00.719><c> is</c><00:00:00.870><c> about</c><00:00:00.960><c> the</c><00:00:01.140><c> new</c><00:00:02.010><c> you'll</c>

00:00:02.690 --> 00:00:02.700 align:start position:0%
this talk is about the new you'll
 

00:00:02.700 --> 00:00:06.519 align:start position:0%
this talk is about the new you'll
optimizer<00:00:03.480><c> and</c><00:00:04.069><c> I</c><00:00:05.069><c> want</c><00:00:05.339><c> to</c><00:00:05.430><c> start</c><00:00:05.670><c> in</c><00:00:05.850><c> a</c><00:00:06.000><c> good</c>

00:00:06.519 --> 00:00:06.529 align:start position:0%
optimizer and I want to start in a good
 

00:00:06.529 --> 00:00:08.299 align:start position:0%
optimizer and I want to start in a good
tradition<00:00:07.529><c> I</c><00:00:07.620><c> want</c><00:00:07.770><c> to</c><00:00:07.830><c> start</c><00:00:08.040><c> with</c><00:00:08.250><c> a</c>

00:00:08.299 --> 00:00:08.309 align:start position:0%
tradition I want to start with a
 

00:00:08.309 --> 00:00:11.330 align:start position:0%
tradition I want to start with a
definition<00:00:08.700><c> what</c><00:00:09.120><c> is</c><00:00:09.150><c> an</c><00:00:09.330><c> optimizer</c><00:00:10.340><c> an</c>

00:00:11.330 --> 00:00:11.340 align:start position:0%
definition what is an optimizer an
 

00:00:11.340 --> 00:00:13.669 align:start position:0%
definition what is an optimizer an
optimizer<00:00:11.790><c> is</c><00:00:11.910><c> a</c><00:00:12.330><c> piece</c><00:00:12.900><c> of</c><00:00:13.049><c> software</c><00:00:13.380><c> that</c>

00:00:13.669 --> 00:00:13.679 align:start position:0%
optimizer is a piece of software that
 

00:00:13.679 --> 00:00:15.799 align:start position:0%
optimizer is a piece of software that
takes<00:00:14.309><c> another</c><00:00:14.910><c> piece</c><00:00:15.120><c> of</c><00:00:15.150><c> software</c><00:00:15.570><c> a</c>

00:00:15.799 --> 00:00:15.809 align:start position:0%
takes another piece of software a
 

00:00:15.809 --> 00:00:18.920 align:start position:0%
takes another piece of software a
program<00:00:16.260><c> as</c><00:00:16.410><c> input</c><00:00:16.800><c> and</c><00:00:17.480><c> transforms</c><00:00:18.480><c> it</c><00:00:18.690><c> into</c>

00:00:18.920 --> 00:00:18.930 align:start position:0%
program as input and transforms it into
 

00:00:18.930 --> 00:00:22.730 align:start position:0%
program as input and transforms it into
a<00:00:19.500><c> new</c><00:00:19.650><c> piece</c><00:00:19.890><c> of</c><00:00:19.920><c> software</c><00:00:20.750><c> that</c><00:00:21.750><c> hopefully</c>

00:00:22.730 --> 00:00:22.740 align:start position:0%
a new piece of software that hopefully
 

00:00:22.740 --> 00:00:25.160 align:start position:0%
a new piece of software that hopefully
requires<00:00:23.100><c> fewer</c><00:00:23.519><c> resources</c><00:00:23.820><c> or</c><00:00:24.210><c> at</c><00:00:24.330><c> least</c><00:00:24.539><c> not</c>

00:00:25.160 --> 00:00:25.170 align:start position:0%
requires fewer resources or at least not
 

00:00:25.170 --> 00:00:29.269 align:start position:0%
requires fewer resources or at least not
more<00:00:25.800><c> and</c><00:00:26.869><c> is</c><00:00:27.869><c> semantically</c><00:00:28.529><c> equivalent</c><00:00:28.769><c> so</c>

00:00:29.269 --> 00:00:29.279 align:start position:0%
more and is semantically equivalent so
 

00:00:29.279 --> 00:00:31.279 align:start position:0%
more and is semantically equivalent so
it<00:00:29.550><c> means</c><00:00:29.760><c> it</c><00:00:29.939><c> does</c><00:00:30.359><c> exactly</c><00:00:30.660><c> the</c><00:00:30.900><c> same</c><00:00:31.050><c> thing</c>

00:00:31.279 --> 00:00:31.289 align:start position:0%
it means it does exactly the same thing
 

00:00:31.289 --> 00:00:35.060 align:start position:0%
it means it does exactly the same thing
and<00:00:32.809><c> both</c><00:00:33.809><c> of</c><00:00:34.050><c> these</c><00:00:34.200><c> components</c><00:00:34.739><c> of</c><00:00:34.980><c> the</c>

00:00:35.060 --> 00:00:35.070 align:start position:0%
and both of these components of the
 

00:00:35.070 --> 00:00:37.250 align:start position:0%
and both of these components of the
definition<00:00:35.579><c> allow</c><00:00:35.940><c> for</c><00:00:36.270><c> some</c><00:00:36.480><c> kind</c><00:00:36.870><c> of</c><00:00:37.050><c> slack</c>

00:00:37.250 --> 00:00:37.260 align:start position:0%
definition allow for some kind of slack
 

00:00:37.260 --> 00:00:40.010 align:start position:0%
definition allow for some kind of slack
so<00:00:37.590><c> both</c><00:00:38.129><c> the</c><00:00:38.670><c> resources</c><00:00:39.149><c> and</c><00:00:39.270><c> the</c><00:00:39.750><c> cement</c>

00:00:40.010 --> 00:00:40.020 align:start position:0%
so both the resources and the cement
 

00:00:40.020 --> 00:00:41.389 align:start position:0%
so both the resources and the cement
equivalents<00:00:40.469><c> but</c><00:00:40.649><c> we</c><00:00:40.770><c> will</c><00:00:40.890><c> touch</c><00:00:41.129><c> on</c><00:00:41.250><c> that</c>

00:00:41.389 --> 00:00:41.399 align:start position:0%
equivalents but we will touch on that
 

00:00:41.399 --> 00:00:44.930 align:start position:0%
equivalents but we will touch on that
later<00:00:41.930><c> let's</c><00:00:42.980><c> see</c><00:00:43.980><c> an</c><00:00:44.070><c> example</c><00:00:44.160><c> so</c><00:00:44.640><c> this</c><00:00:44.789><c> is</c>

00:00:44.930 --> 00:00:44.940 align:start position:0%
later let's see an example so this is
 

00:00:44.940 --> 00:00:48.619 align:start position:0%
later let's see an example so this is
solidity<00:00:45.329><c> code</c><00:00:46.399><c> that</c><00:00:47.399><c> computes</c><00:00:47.789><c> the</c><00:00:48.600><c> square</c>

00:00:48.619 --> 00:00:48.629 align:start position:0%
solidity code that computes the square
 

00:00:48.629 --> 00:00:53.680 align:start position:0%
solidity code that computes the square
of<00:00:49.440><c> the</c><00:00:49.920><c> input</c><00:00:50.070><c> number</c><00:00:50.520><c> and</c><00:00:52.039><c> it</c><00:00:53.039><c> uses</c><00:00:53.219><c> the</c>

00:00:53.680 --> 00:00:53.690 align:start position:0%
of the input number and it uses the
 

00:00:53.690 --> 00:00:57.650 align:start position:0%
of the input number and it uses the
exponentiation<00:00:54.890><c> operation</c><00:00:55.890><c> which</c><00:00:56.789><c> is</c><00:00:56.820><c> quite</c>

00:00:57.650 --> 00:00:57.660 align:start position:0%
exponentiation operation which is quite
 

00:00:57.660 --> 00:00:59.869 align:start position:0%
exponentiation operation which is quite
expensive<00:00:57.930><c> on</c><00:00:58.260><c> the</c><00:00:58.350><c> EVM</c><00:00:58.710><c> and</c><00:00:59.039><c> the</c><00:00:59.430><c> same</c><00:00:59.609><c> thing</c>

00:00:59.869 --> 00:00:59.879 align:start position:0%
expensive on the EVM and the same thing
 

00:00:59.879 --> 00:01:01.369 align:start position:0%
expensive on the EVM and the same thing
can<00:01:00.120><c> be</c><00:01:00.180><c> achieved</c><00:01:00.359><c> with</c><00:01:00.780><c> just</c><00:01:01.079><c> a</c>

00:01:01.369 --> 00:01:01.379 align:start position:0%
can be achieved with just a
 

00:01:01.379 --> 00:01:05.179 align:start position:0%
can be achieved with just a
multiplication<00:01:01.829><c> multiplication</c><00:01:02.719><c> of</c><00:01:03.719><c> X</c><00:01:04.530><c> by</c>

00:01:05.179 --> 00:01:05.189 align:start position:0%
multiplication multiplication of X by
 

00:01:05.189 --> 00:01:08.539 align:start position:0%
multiplication multiplication of X by
itself<00:01:05.220><c> and</c><00:01:05.930><c> so</c><00:01:06.930><c> such</c><00:01:07.560><c> a</c><00:01:07.680><c> transformation</c><00:01:08.369><c> on</c>

00:01:08.539 --> 00:01:08.549 align:start position:0%
itself and so such a transformation on
 

00:01:08.549 --> 00:01:12.730 align:start position:0%
itself and so such a transformation on
solidity<00:01:09.299><c> would</c><00:01:09.990><c> be</c><00:01:10.200><c> a</c><00:01:10.970><c> valid</c><00:01:11.970><c> optimization</c>

00:01:12.730 --> 00:01:12.740 align:start position:0%
solidity would be a valid optimization
 

00:01:12.740 --> 00:01:15.859 align:start position:0%
solidity would be a valid optimization
optimizer<00:01:14.330><c> transformation</c><00:01:15.330><c> because</c><00:01:15.570><c> it</c><00:01:15.720><c> does</c>

00:01:15.859 --> 00:01:15.869 align:start position:0%
optimizer transformation because it does
 

00:01:15.869 --> 00:01:19.070 align:start position:0%
optimizer transformation because it does
the<00:01:15.990><c> same</c><00:01:16.170><c> thing</c><00:01:16.380><c> and</c><00:01:16.650><c> it's</c><00:01:17.280><c> cheaper</c><00:01:17.869><c> okay</c><00:01:18.869><c> but</c>

00:01:19.070 --> 00:01:19.080 align:start position:0%
the same thing and it's cheaper okay but
 

00:01:19.080 --> 00:01:21.230 align:start position:0%
the same thing and it's cheaper okay but
we<00:01:19.680><c> don't</c><00:01:19.710><c> want</c><00:01:19.979><c> to</c><00:01:20.040><c> optimize</c><00:01:20.759><c> solidity</c>

00:01:21.230 --> 00:01:21.240 align:start position:0%
we don't want to optimize solidity
 

00:01:21.240 --> 00:01:23.450 align:start position:0%
we don't want to optimize solidity
directly<00:01:21.840><c> we</c><00:01:22.229><c> want</c><00:01:22.439><c> to</c><00:01:22.560><c> optimize</c><00:01:23.009><c> the</c>

00:01:23.450 --> 00:01:23.460 align:start position:0%
directly we want to optimize the
 

00:01:23.460 --> 00:01:27.100 align:start position:0%
directly we want to optimize the
low-level<00:01:24.500><c> language</c><00:01:25.500><c> that</c><00:01:25.830><c> we'll</c><00:01:26.009><c> see</c><00:01:26.220><c> later</c>

00:01:27.100 --> 00:01:27.110 align:start position:0%
low-level language that we'll see later
 

00:01:27.110 --> 00:01:30.499 align:start position:0%
low-level language that we'll see later
this<00:01:28.110><c> thing</c><00:01:28.409><c> has</c><00:01:29.100><c> two</c><00:01:29.460><c> problems</c><00:01:29.970><c> the</c><00:01:30.060><c> first</c>

00:01:30.499 --> 00:01:30.509 align:start position:0%
this thing has two problems the first
 

00:01:30.509 --> 00:01:33.230 align:start position:0%
this thing has two problems the first
one<00:01:30.840><c> touches</c><00:01:31.710><c> on</c><00:01:31.829><c> the</c><00:01:31.920><c> resources</c><00:01:32.280><c> part</c><00:01:32.850><c> so</c>

00:01:33.230 --> 00:01:33.240 align:start position:0%
one touches on the resources part so
 

00:01:33.240 --> 00:01:35.929 align:start position:0%
one touches on the resources part so
what<00:01:34.200><c> are</c><00:01:34.409><c> actually</c><00:01:34.950><c> the</c><00:01:35.189><c> resources</c><00:01:35.670><c> we</c><00:01:35.790><c> want</c>

00:01:35.929 --> 00:01:35.939 align:start position:0%
what are actually the resources we want
 

00:01:35.939 --> 00:01:39.020 align:start position:0%
what are actually the resources we want
to<00:01:36.030><c> optimize</c><00:01:36.270><c> on</c><00:01:37.200><c> the</c><00:01:37.950><c> EVM</c><00:01:38.310><c> this</c><00:01:38.610><c> might</c><00:01:38.850><c> be</c>

00:01:39.020 --> 00:01:39.030 align:start position:0%
to optimize on the EVM this might be
 

00:01:39.030 --> 00:01:40.249 align:start position:0%
to optimize on the EVM this might be
trivial<00:01:39.450><c> of</c><00:01:39.570><c> course</c><00:01:39.810><c> we</c><00:01:39.900><c> want</c><00:01:40.020><c> to</c><00:01:40.079><c> optimize</c>

00:01:40.249 --> 00:01:40.259 align:start position:0%
trivial of course we want to optimize
 

00:01:40.259 --> 00:01:42.889 align:start position:0%
trivial of course we want to optimize
for<00:01:40.409><c> gas</c><00:01:40.740><c> but</c><00:01:41.640><c> if</c><00:01:41.939><c> you</c><00:01:42.119><c> take</c><00:01:42.420><c> a</c><00:01:42.450><c> closer</c><00:01:42.750><c> look</c>

00:01:42.889 --> 00:01:42.899 align:start position:0%
for gas but if you take a closer look
 

00:01:42.899 --> 00:01:46.630 align:start position:0%
for gas but if you take a closer look
then<00:01:43.290><c> you</c><00:01:43.320><c> see</c><00:01:43.710><c> that</c><00:01:44.030><c> yeah</c><00:01:45.060><c> gas</c><00:01:45.450><c> is</c><00:01:45.689><c> not</c>

00:01:46.630 --> 00:01:46.640 align:start position:0%
then you see that yeah gas is not
 

00:01:46.640 --> 00:01:49.670 align:start position:0%
then you see that yeah gas is not
yeahthere's<00:01:47.640><c> knows</c><00:01:48.060><c> not</c><00:01:48.689><c> a</c><00:01:48.750><c> unique</c><00:01:49.140><c> thing</c><00:01:49.500><c> you</c>

00:01:49.670 --> 00:01:49.680 align:start position:0%
yeahthere's knows not a unique thing you
 

00:01:49.680 --> 00:01:52.399 align:start position:0%
yeahthere's knows not a unique thing you
can<00:01:49.829><c> call</c><00:01:50.070><c> a</c><00:01:50.130><c> gas</c><00:01:50.369><c> or</c><00:01:50.909><c> gas</c><00:01:51.509><c> usage</c><00:01:51.960><c> of</c><00:01:52.110><c> a</c><00:01:52.170><c> smart</c>

00:01:52.399 --> 00:01:52.409 align:start position:0%
can call a gas or gas usage of a smart
 

00:01:52.409 --> 00:01:53.690 align:start position:0%
can call a gas or gas usage of a smart
contract<00:01:52.770><c> because</c><00:01:53.009><c> there</c><00:01:53.130><c> are</c><00:01:53.189><c> at</c><00:01:53.280><c> least</c><00:01:53.310><c> two</c>

00:01:53.690 --> 00:01:53.700 align:start position:0%
contract because there are at least two
 

00:01:53.700 --> 00:01:56.569 align:start position:0%
contract because there are at least two
the<00:01:54.270><c> first</c><00:01:54.450><c> is</c><00:01:54.780><c> the</c><00:01:55.500><c> gas</c><00:01:55.680><c> that</c><00:01:55.950><c> is</c><00:01:56.070><c> required</c><00:01:56.399><c> to</c>

00:01:56.569 --> 00:01:56.579 align:start position:0%
the first is the gas that is required to
 

00:01:56.579 --> 00:01:58.459 align:start position:0%
the first is the gas that is required to
deploy<00:01:56.820><c> the</c><00:01:57.299><c> smart</c><00:01:57.509><c> contract</c><00:01:57.960><c> and</c><00:01:58.170><c> the</c><00:01:58.229><c> second</c>

00:01:58.459 --> 00:01:58.469 align:start position:0%
deploy the smart contract and the second
 

00:01:58.469 --> 00:02:00.109 align:start position:0%
deploy the smart contract and the second
thing<00:01:58.619><c> is</c><00:01:58.799><c> the</c><00:01:58.979><c> gas</c><00:01:59.130><c> that</c><00:01:59.369><c> is</c><00:01:59.490><c> required</c><00:01:59.820><c> later</c>

00:02:00.109 --> 00:02:00.119 align:start position:0%
thing is the gas that is required later
 

00:02:00.119 --> 00:02:02.380 align:start position:0%
thing is the gas that is required later
if<00:02:00.479><c> you</c><00:02:00.600><c> call</c><00:02:00.869><c> individual</c><00:02:01.590><c> functions</c><00:02:01.979><c> and</c>

00:02:02.380 --> 00:02:02.390 align:start position:0%
if you call individual functions and
 

00:02:02.390 --> 00:02:06.980 align:start position:0%
if you call individual functions and
this<00:02:03.390><c> is</c><00:02:03.509><c> a</c><00:02:03.659><c> yeah</c><00:02:04.259><c> this</c><00:02:05.189><c> is</c><00:02:05.340><c> a</c><00:02:05.689><c> trade</c><00:02:06.689><c> if</c><00:02:06.840><c> that</c>

00:02:06.980 --> 00:02:06.990 align:start position:0%
this is a yeah this is a trade if that
 

00:02:06.990 --> 00:02:08.540 align:start position:0%
this is a yeah this is a trade if that
actually<00:02:07.140><c> matters</c><00:02:07.619><c> later</c><00:02:07.829><c> because</c><00:02:08.310><c> some</c>

00:02:08.540 --> 00:02:08.550 align:start position:0%
actually matters later because some
 

00:02:08.550 --> 00:02:12.530 align:start position:0%
actually matters later because some
routines<00:02:08.970><c> if</c><00:02:09.420><c> you</c><00:02:11.120><c> transform</c><00:02:12.120><c> them</c><00:02:12.360><c> to</c>

00:02:12.530 --> 00:02:12.540 align:start position:0%
routines if you transform them to
 

00:02:12.540 --> 00:02:13.640 align:start position:0%
routines if you transform them to
something<00:02:12.780><c> that</c><00:02:12.930><c> is</c><00:02:13.200><c> more</c>

00:02:13.640 --> 00:02:13.650 align:start position:0%
something that is more
 

00:02:13.650 --> 00:02:16.300 align:start position:0%
something that is more
compact<00:02:13.950><c> but</c><00:02:14.159><c> does</c><00:02:14.280><c> the</c><00:02:14.400><c> same</c><00:02:14.579><c> thing</c><00:02:14.819><c> then</c>

00:02:16.300 --> 00:02:16.310 align:start position:0%
compact but does the same thing then
 

00:02:16.310 --> 00:02:18.979 align:start position:0%
compact but does the same thing then
this<00:02:17.310><c> reduces</c><00:02:17.640><c> deploy</c><00:02:18.090><c> time</c><00:02:18.329><c> cost</c><00:02:18.599><c> but</c><00:02:18.810><c> most</c>

00:02:18.979 --> 00:02:18.989 align:start position:0%
this reduces deploy time cost but most
 

00:02:18.989 --> 00:02:21.410 align:start position:0%
this reduces deploy time cost but most
of<00:02:19.079><c> the</c><00:02:19.140><c> time</c><00:02:19.349><c> it</c><00:02:19.620><c> increases</c><00:02:20.129><c> runtime</c><00:02:21.090><c> costs</c>

00:02:21.410 --> 00:02:21.420 align:start position:0%
of the time it increases runtime costs
 

00:02:21.420 --> 00:02:25.640 align:start position:0%
of the time it increases runtime costs
so<00:02:21.989><c> and</c><00:02:22.909><c> the</c><00:02:23.909><c> current</c><00:02:24.390><c> optimizer</c><00:02:24.870><c> also</c><00:02:25.439><c> has</c><00:02:25.620><c> a</c>

00:02:25.640 --> 00:02:25.650 align:start position:0%
so and the current optimizer also has a
 

00:02:25.650 --> 00:02:28.460 align:start position:0%
so and the current optimizer also has a
flag<00:02:26.430><c> where</c><00:02:27.000><c> you</c><00:02:27.090><c> can</c><00:02:27.329><c> set</c><00:02:27.930><c> exactly</c><00:02:28.260><c> this</c>

00:02:28.460 --> 00:02:28.470 align:start position:0%
flag where you can set exactly this
 

00:02:28.470 --> 00:02:30.589 align:start position:0%
flag where you can set exactly this
trade-off<00:02:28.829><c> it's</c><00:02:29.159><c> called</c><00:02:29.400><c> the</c><00:02:29.549><c> runs</c><00:02:29.790><c> parameter</c>

00:02:30.589 --> 00:02:30.599 align:start position:0%
trade-off it's called the runs parameter
 

00:02:30.599 --> 00:02:33.170 align:start position:0%
trade-off it's called the runs parameter
this<00:02:31.319><c> is</c><00:02:31.379><c> often</c><00:02:31.709><c> misinterpreted</c><00:02:32.220><c> as</c><00:02:32.760><c> just</c><00:02:33.090><c> the</c>

00:02:33.170 --> 00:02:33.180 align:start position:0%
this is often misinterpreted as just the
 

00:02:33.180 --> 00:02:35.750 align:start position:0%
this is often misinterpreted as just the
number<00:02:33.450><c> of</c><00:02:33.480><c> runs</c><00:02:33.780><c> you</c><00:02:34.200><c> want</c><00:02:34.409><c> to</c><00:02:34.700><c> amount</c><00:02:35.700><c> of</c>

00:02:35.750 --> 00:02:35.760 align:start position:0%
number of runs you want to amount of
 

00:02:35.760 --> 00:02:36.890 align:start position:0%
number of runs you want to amount of
effort<00:02:35.939><c> you</c><00:02:36.090><c> want</c><00:02:36.269><c> to</c><00:02:36.329><c> put</c><00:02:36.540><c> into</c><00:02:36.750><c> the</c>

00:02:36.890 --> 00:02:36.900 align:start position:0%
effort you want to put into the
 

00:02:36.900 --> 00:02:38.990 align:start position:0%
effort you want to put into the
optimizer<00:02:37.319><c> but</c><00:02:37.859><c> it's</c><00:02:37.950><c> actually</c><00:02:38.159><c> exactly</c><00:02:38.609><c> this</c>

00:02:38.990 --> 00:02:39.000 align:start position:0%
optimizer but it's actually exactly this
 

00:02:39.000 --> 00:02:41.449 align:start position:0%
optimizer but it's actually exactly this
trade-off<00:02:39.329><c> and</c><00:02:39.659><c> this</c><00:02:40.620><c> trade-off</c><00:02:40.890><c> problem</c>

00:02:41.449 --> 00:02:41.459 align:start position:0%
trade-off and this trade-off problem
 

00:02:41.459 --> 00:02:43.339 align:start position:0%
trade-off and this trade-off problem
gets<00:02:42.060><c> even</c><00:02:42.269><c> more</c><00:02:42.299><c> complicated</c><00:02:42.780><c> when</c><00:02:43.230><c> you</c><00:02:43.319><c> have</c>

00:02:43.339 --> 00:02:43.349 align:start position:0%
gets even more complicated when you have
 

00:02:43.349 --> 00:02:47.809 align:start position:0%
gets even more complicated when you have
loops<00:02:43.799><c> because</c><00:02:44.340><c> then</c><00:02:44.640><c> you</c><00:02:44.939><c> might</c><00:02:45.150><c> want</c><00:02:45.450><c> to</c><00:02:46.819><c> you</c>

00:02:47.809 --> 00:02:47.819 align:start position:0%
loops because then you might want to you
 

00:02:47.819 --> 00:02:50.539 align:start position:0%
loops because then you might want to you
so<00:02:48.290><c> for</c><00:02:49.290><c> the</c><00:02:49.470><c> code</c><00:02:49.680><c> that</c><00:02:49.829><c> is</c><00:02:49.950><c> inside</c><00:02:50.190><c> the</c><00:02:50.250><c> loop</c>

00:02:50.539 --> 00:02:50.549 align:start position:0%
so for the code that is inside the loop
 

00:02:50.549 --> 00:02:52.369 align:start position:0%
so for the code that is inside the loop
that<00:02:50.670><c> is</c><00:02:50.730><c> executed</c><00:02:51.269><c> executed</c><00:02:51.900><c> more</c><00:02:52.079><c> often</c>

00:02:52.369 --> 00:02:52.379 align:start position:0%
that is executed executed more often
 

00:02:52.379 --> 00:02:54.129 align:start position:0%
that is executed executed more often
than<00:02:52.530><c> the</c><00:02:52.620><c> code</c><00:02:52.799><c> outside</c><00:02:52.980><c> of</c><00:02:53.310><c> the</c><00:02:53.400><c> loop</c><00:02:53.549><c> so</c>

00:02:54.129 --> 00:02:54.139 align:start position:0%
than the code outside of the loop so
 

00:02:54.139 --> 00:02:56.390 align:start position:0%
than the code outside of the loop so
there<00:02:55.139><c> it's</c><00:02:55.379><c> even</c><00:02:55.590><c> more</c><00:02:55.739><c> important</c><00:02:56.220><c> that</c><00:02:56.250><c> the</c>

00:02:56.390 --> 00:02:56.400 align:start position:0%
there it's even more important that the
 

00:02:56.400 --> 00:02:59.599 align:start position:0%
there it's even more important that the
runtime<00:02:56.790><c> costs</c><00:02:57.209><c> are</c><00:02:57.299><c> lower</c><00:02:57.480><c> and</c><00:02:57.750><c> you</c><00:02:57.900><c> might</c><00:02:58.609><c> be</c>

00:02:59.599 --> 00:02:59.609 align:start position:0%
runtime costs are lower and you might be
 

00:02:59.609 --> 00:03:02.119 align:start position:0%
runtime costs are lower and you might be
fine<00:02:59.849><c> with</c><00:03:00.030><c> a</c><00:03:00.060><c> little</c><00:03:00.150><c> bit</c><00:03:00.450><c> more</c><00:03:00.889><c> deploy</c><00:03:01.889><c> time</c>

00:03:02.119 --> 00:03:02.129 align:start position:0%
fine with a little bit more deploy time
 

00:03:02.129 --> 00:03:04.339 align:start position:0%
fine with a little bit more deploy time
costs<00:03:02.489><c> in</c><00:03:02.639><c> such</c><00:03:02.790><c> cases</c><00:03:03.000><c> but</c><00:03:03.269><c> yeah</c><00:03:03.959><c> these</c><00:03:04.139><c> are</c>

00:03:04.339 --> 00:03:04.349 align:start position:0%
costs in such cases but yeah these are
 

00:03:04.349 --> 00:03:06.319 align:start position:0%
costs in such cases but yeah these are
tough<00:03:04.829><c> decisions</c><00:03:04.889><c> for</c><00:03:05.430><c> the</c><00:03:05.549><c> optimizer</c><00:03:05.939><c> and</c><00:03:06.090><c> it</c>

00:03:06.319 --> 00:03:06.329 align:start position:0%
tough decisions for the optimizer and it
 

00:03:06.329 --> 00:03:09.199 align:start position:0%
tough decisions for the optimizer and it
will<00:03:06.629><c> not</c><00:03:06.810><c> always</c><00:03:06.930><c> get</c><00:03:07.200><c> it</c><00:03:07.319><c> right</c><00:03:07.500><c> and</c><00:03:08.209><c> the</c>

00:03:09.199 --> 00:03:09.209 align:start position:0%
will not always get it right and the
 

00:03:09.209 --> 00:03:11.509 align:start position:0%
will not always get it right and the
second<00:03:09.540><c> problem</c><00:03:09.689><c> is</c><00:03:10.049><c> that</c><00:03:10.680><c> even</c><00:03:10.920><c> if</c><00:03:11.159><c> you</c><00:03:11.340><c> have</c>

00:03:11.509 --> 00:03:11.519 align:start position:0%
second problem is that even if you have
 

00:03:11.519 --> 00:03:13.399 align:start position:0%
second problem is that even if you have
a<00:03:11.549><c> clearly</c><00:03:12.180><c> defined</c><00:03:12.540><c> mathematically</c><00:03:13.139><c> defined</c>

00:03:13.399 --> 00:03:13.409 align:start position:0%
a clearly defined mathematically defined
 

00:03:13.409 --> 00:03:16.369 align:start position:0%
a clearly defined mathematically defined
metric<00:03:13.799><c> for</c><00:03:14.099><c> resource</c><00:03:14.760><c> consumption</c><00:03:15.319><c> it</c><00:03:16.319><c> is</c>

00:03:16.369 --> 00:03:16.379 align:start position:0%
metric for resource consumption it is
 

00:03:16.379 --> 00:03:18.619 align:start position:0%
metric for resource consumption it is
theoretically<00:03:17.069><c> impossible</c><00:03:17.400><c> to</c><00:03:18.150><c> create</c><00:03:18.449><c> a</c>

00:03:18.619 --> 00:03:18.629 align:start position:0%
theoretically impossible to create a
 

00:03:18.629 --> 00:03:21.110 align:start position:0%
theoretically impossible to create a
perfect<00:03:19.290><c> optimizer</c><00:03:19.739><c> and</c><00:03:19.919><c> perfect</c><00:03:20.790><c> optimizer</c>

00:03:21.110 --> 00:03:21.120 align:start position:0%
perfect optimizer and perfect optimizer
 

00:03:21.120 --> 00:03:23.890 align:start position:0%
perfect optimizer and perfect optimizer
means<00:03:21.389><c> it</c><00:03:22.379><c> takes</c><00:03:22.590><c> a</c><00:03:22.769><c> program</c><00:03:23.069><c> is</c><00:03:23.160><c> input</c><00:03:23.519><c> and</c>

00:03:23.890 --> 00:03:23.900 align:start position:0%
means it takes a program is input and
 

00:03:23.900 --> 00:03:26.689 align:start position:0%
means it takes a program is input and
the<00:03:24.900><c> output</c><00:03:24.930><c> program</c><00:03:25.590><c> is</c><00:03:25.799><c> the</c><00:03:26.040><c> best</c><00:03:26.160><c> possible</c>

00:03:26.689 --> 00:03:26.699 align:start position:0%
the output program is the best possible
 

00:03:26.699 --> 00:03:28.490 align:start position:0%
the output program is the best possible
program<00:03:27.000><c> that</c><00:03:27.120><c> does</c><00:03:27.239><c> the</c><00:03:27.359><c> same</c><00:03:27.389><c> thing</c><00:03:27.780><c> with</c>

00:03:28.490 --> 00:03:28.500 align:start position:0%
program that does the same thing with
 

00:03:28.500 --> 00:03:30.800 align:start position:0%
program that does the same thing with
the<00:03:28.829><c> least</c><00:03:29.340><c> amount</c><00:03:29.579><c> of</c><00:03:29.819><c> resource</c><00:03:30.150><c> usage</c><00:03:30.599><c> and</c>

00:03:30.800 --> 00:03:30.810 align:start position:0%
the least amount of resource usage and
 

00:03:30.810 --> 00:03:36.680 align:start position:0%
the least amount of resource usage and
the<00:03:31.139><c> reason</c><00:03:31.500><c> for</c><00:03:31.530><c> that</c><00:03:31.680><c> is</c><00:03:32.840><c> yeah</c><00:03:33.840><c> not</c><00:03:34.190><c> not</c><00:03:35.690><c> the</c>

00:03:36.680 --> 00:03:36.690 align:start position:0%
the reason for that is yeah not not the
 

00:03:36.690 --> 00:03:38.569 align:start position:0%
the reason for that is yeah not not the
problem<00:03:36.989><c> that</c><00:03:37.319><c> that</c><00:03:37.530><c> finding</c><00:03:37.859><c> this</c><00:03:38.159><c> optimal</c>

00:03:38.569 --> 00:03:38.579 align:start position:0%
problem that that finding this optimal
 

00:03:38.579 --> 00:03:41.089 align:start position:0%
problem that that finding this optimal
program<00:03:39.030><c> is</c><00:03:39.329><c> too</c><00:03:40.049><c> difficult</c><00:03:40.319><c> because</c><00:03:40.980><c> the</c>

00:03:41.089 --> 00:03:41.099 align:start position:0%
program is too difficult because the
 

00:03:41.099 --> 00:03:42.589 align:start position:0%
program is too difficult because the
search<00:03:41.310><c> space</c><00:03:41.579><c> is</c><00:03:41.609><c> too</c><00:03:41.909><c> large</c><00:03:42.090><c> or</c><00:03:42.329><c> something</c>

00:03:42.589 --> 00:03:42.599 align:start position:0%
search space is too large or something
 

00:03:42.599 --> 00:03:45.050 align:start position:0%
search space is too large or something
like<00:03:42.659><c> that</c><00:03:42.810><c> but</c><00:03:43.319><c> it's</c><00:03:44.040><c> the</c><00:03:44.669><c> semantic</c>

00:03:45.050 --> 00:03:45.060 align:start position:0%
like that but it's the semantic
 

00:03:45.060 --> 00:03:48.890 align:start position:0%
like that but it's the semantic
equivalence<00:03:45.419><c> and</c><00:03:46.519><c> more</c><00:03:47.519><c> specifically</c><00:03:48.090><c> you</c>

00:03:48.890 --> 00:03:48.900 align:start position:0%
equivalence and more specifically you
 

00:03:48.900 --> 00:03:50.930 align:start position:0%
equivalence and more specifically you
probably<00:03:49.709><c> heard</c><00:03:50.190><c> about</c><00:03:50.310><c> the</c><00:03:50.609><c> halting</c><00:03:50.909><c> problem</c>

00:03:50.930 --> 00:03:50.940 align:start position:0%
probably heard about the halting problem
 

00:03:50.940 --> 00:03:53.809 align:start position:0%
probably heard about the halting problem
that<00:03:51.389><c> gets</c><00:03:51.510><c> cited</c><00:03:51.810><c> all</c><00:03:52.560><c> the</c><00:03:52.979><c> way</c><00:03:53.099><c> in</c><00:03:53.430><c> Turing</c>

00:03:53.809 --> 00:03:53.819 align:start position:0%
that gets cited all the way in Turing
 

00:03:53.819 --> 00:03:58.640 align:start position:0%
that gets cited all the way in Turing
complete<00:03:54.620><c> for</c><00:03:55.620><c> Turing</c><00:03:55.859><c> complete</c><00:03:57.650><c> blockchain</c>

00:03:58.640 --> 00:03:58.650 align:start position:0%
complete for Turing complete blockchain
 

00:03:58.650 --> 00:04:01.610 align:start position:0%
complete for Turing complete blockchain
smart<00:03:59.129><c> contract</c><00:04:00.109><c> execution</c><00:04:01.109><c> environments</c>

00:04:01.610 --> 00:04:01.620 align:start position:0%
smart contract execution environments
 

00:04:01.620 --> 00:04:06.649 align:start position:0%
smart contract execution environments
and<00:04:03.709><c> you</c><00:04:04.709><c> can</c><00:04:04.859><c> show</c><00:04:05.099><c> via</c><00:04:05.909><c> the</c><00:04:06.120><c> halting</c><00:04:06.419><c> problem</c>

00:04:06.649 --> 00:04:06.659 align:start position:0%
and you can show via the halting problem
 

00:04:06.659 --> 00:04:09.770 align:start position:0%
and you can show via the halting problem
that<00:04:07.049><c> a</c><00:04:07.579><c> perfect</c><00:04:08.579><c> optimizer</c><00:04:08.940><c> is</c><00:04:09.209><c> impossible</c>

00:04:09.770 --> 00:04:09.780 align:start position:0%
that a perfect optimizer is impossible
 

00:04:09.780 --> 00:04:13.099 align:start position:0%
that a perfect optimizer is impossible
and<00:04:10.760><c> yeah</c><00:04:11.760><c> the</c><00:04:11.879><c> halting</c><00:04:12.180><c> problem</c><00:04:12.209><c> is</c><00:04:12.690><c> that</c>

00:04:13.099 --> 00:04:13.109 align:start position:0%
and yeah the halting problem is that
 

00:04:13.109 --> 00:04:15.649 align:start position:0%
and yeah the halting problem is that
it's<00:04:13.829><c> a</c><00:04:14.010><c> result</c><00:04:14.790><c> from</c><00:04:14.940><c> theoretical</c><00:04:15.389><c> computer</c>

00:04:15.649 --> 00:04:15.659 align:start position:0%
it's a result from theoretical computer
 

00:04:15.659 --> 00:04:16.909 align:start position:0%
it's a result from theoretical computer
science<00:04:15.900><c> and</c><00:04:16.019><c> it</c><00:04:16.079><c> says</c><00:04:16.229><c> that</c><00:04:16.470><c> there</c><00:04:16.709><c> is</c><00:04:16.799><c> no</c>

00:04:16.909 --> 00:04:16.919 align:start position:0%
science and it says that there is no
 

00:04:16.919 --> 00:04:20.000 align:start position:0%
science and it says that there is no
program<00:04:17.159><c> that</c><00:04:17.669><c> decides</c><00:04:18.630><c> on</c><00:04:18.810><c> a</c><00:04:18.900><c> given</c><00:04:19.199><c> input</c>

00:04:20.000 --> 00:04:20.010 align:start position:0%
program that decides on a given input
 

00:04:20.010 --> 00:04:21.709 align:start position:0%
program that decides on a given input
program<00:04:20.549><c> whether</c><00:04:20.699><c> it</c><00:04:21.000><c> halts</c><00:04:21.419><c> on</c><00:04:21.510><c> all</c><00:04:21.570><c> inputs</c>

00:04:21.709 --> 00:04:21.719 align:start position:0%
program whether it halts on all inputs
 

00:04:21.719 --> 00:04:23.409 align:start position:0%
program whether it halts on all inputs
or<00:04:22.320><c> not</c>

00:04:23.409 --> 00:04:23.419 align:start position:0%
or not
 

00:04:23.419 --> 00:04:26.260 align:start position:0%
or not
and<00:04:23.710><c> because</c><00:04:24.710><c> we're</c><00:04:24.949><c> in</c><00:04:24.979><c> on</c><00:04:25.370><c> the</c><00:04:25.490><c> EVM</c><00:04:25.789><c> here</c><00:04:26.090><c> we</c>

00:04:26.260 --> 00:04:26.270 align:start position:0%
and because we're in on the EVM here we
 

00:04:26.270 --> 00:04:29.020 align:start position:0%
and because we're in on the EVM here we
replace<00:04:26.659><c> halt</c><00:04:27.110><c> by</c><00:04:27.319><c> revert</c><00:04:27.650><c> and</c><00:04:27.949><c> this</c><00:04:28.759><c> is</c><00:04:28.879><c> still</c>

00:04:29.020 --> 00:04:29.030 align:start position:0%
replace halt by revert and this is still
 

00:04:29.030 --> 00:04:34.899 align:start position:0%
replace halt by revert and this is still
true<00:04:29.150><c> and</c><00:04:30.999><c> so</c><00:04:32.710><c> we</c><00:04:33.710><c> now</c><00:04:33.830><c> assume</c><00:04:34.249><c> that</c><00:04:34.279><c> we</c><00:04:34.669><c> have</c><00:04:34.699><c> a</c>

00:04:34.899 --> 00:04:34.909 align:start position:0%
true and so we now assume that we have a
 

00:04:34.909 --> 00:04:37.089 align:start position:0%
true and so we now assume that we have a
perfect<00:04:35.210><c> optimizer</c><00:04:35.810><c> and</c><00:04:36.139><c> use</c><00:04:36.379><c> that</c><00:04:36.680><c> perfect</c>

00:04:37.089 --> 00:04:37.099 align:start position:0%
perfect optimizer and use that perfect
 

00:04:37.099 --> 00:04:38.679 align:start position:0%
perfect optimizer and use that perfect
optimizer<00:04:37.490><c> to</c><00:04:37.999><c> solve</c><00:04:38.240><c> the</c><00:04:38.389><c> halting</c><00:04:38.479><c> problem</c>

00:04:38.679 --> 00:04:38.689 align:start position:0%
optimizer to solve the halting problem
 

00:04:38.689 --> 00:04:41.080 align:start position:0%
optimizer to solve the halting problem
and<00:04:39.199><c> because</c><00:04:39.650><c> of</c><00:04:39.680><c> that</c><00:04:39.889><c> perfect</c><00:04:40.340><c> optimizer</c><00:04:40.789><c> is</c>

00:04:41.080 --> 00:04:41.090 align:start position:0%
and because of that perfect optimizer is
 

00:04:41.090 --> 00:04:45.149 align:start position:0%
and because of that perfect optimizer is
impossible<00:04:41.689><c> and</c><00:04:43.060><c> yeah</c><00:04:44.060><c> the</c><00:04:44.240><c> way</c><00:04:44.389><c> we</c><00:04:44.539><c> do</c><00:04:44.689><c> it</c><00:04:44.840><c> is</c>

00:04:45.149 --> 00:04:45.159 align:start position:0%
impossible and yeah the way we do it is
 

00:04:45.159 --> 00:04:49.629 align:start position:0%
impossible and yeah the way we do it is
so<00:04:46.689><c> if</c><00:04:47.689><c> a</c><00:04:48.020><c> program</c><00:04:48.229><c> reverts</c><00:04:48.979><c> on</c><00:04:49.219><c> all</c><00:04:49.430><c> inputs</c>

00:04:49.629 --> 00:04:49.639 align:start position:0%
so if a program reverts on all inputs
 

00:04:49.639 --> 00:04:53.769 align:start position:0%
so if a program reverts on all inputs
and<00:04:50.120><c> it's</c><00:04:50.840><c> the</c><00:04:51.110><c> shortest</c><00:04:51.919><c> program</c><00:04:52.669><c> then</c><00:04:53.360><c> it</c>

00:04:53.769 --> 00:04:53.779 align:start position:0%
and it's the shortest program then it
 

00:04:53.779 --> 00:04:55.450 align:start position:0%
and it's the shortest program then it
has<00:04:53.990><c> to</c><00:04:54.229><c> look</c><00:04:54.379><c> something</c><00:04:54.740><c> like</c><00:04:54.800><c> this</c><00:04:55.159><c> empty</c>

00:04:55.450 --> 00:04:55.460 align:start position:0%
has to look something like this empty
 

00:04:55.460 --> 00:04:58.179 align:start position:0%
has to look something like this empty
contract<00:04:55.849><c> here</c><00:04:56.620><c> because</c><00:04:57.620><c> that's</c><00:04:57.740><c> the</c><00:04:57.949><c> shorter</c>

00:04:58.179 --> 00:04:58.189 align:start position:0%
contract here because that's the shorter
 

00:04:58.189 --> 00:04:59.980 align:start position:0%
contract here because that's the shorter
program<00:04:58.909><c> that</c><00:04:59.029><c> revolts</c><00:04:59.330><c> on</c><00:04:59.419><c> all</c><00:04:59.509><c> inputs</c><00:04:59.659><c> and</c>

00:04:59.980 --> 00:04:59.990 align:start position:0%
program that revolts on all inputs and
 

00:04:59.990 --> 00:05:03.070 align:start position:0%
program that revolts on all inputs and
so<00:05:00.819><c> to</c><00:05:01.819><c> decide</c><00:05:02.029><c> the</c><00:05:02.180><c> halting</c><00:05:02.300><c> problem</c><00:05:02.479><c> we</c><00:05:02.870><c> take</c>

00:05:03.070 --> 00:05:03.080 align:start position:0%
so to decide the halting problem we take
 

00:05:03.080 --> 00:05:04.809 align:start position:0%
so to decide the halting problem we take
the<00:05:03.259><c> perfect</c><00:05:03.439><c> optimizer</c><00:05:03.979><c> run</c><00:05:04.430><c> it</c><00:05:04.550><c> on</c><00:05:04.669><c> the</c>

00:05:04.809 --> 00:05:04.819 align:start position:0%
the perfect optimizer run it on the
 

00:05:04.819 --> 00:05:07.869 align:start position:0%
the perfect optimizer run it on the
input<00:05:05.120><c> and</c><00:05:05.360><c> if</c><00:05:05.539><c> it</c><00:05:05.629><c> outputs</c><00:05:05.719><c> this</c><00:05:06.430><c> empty</c><00:05:07.430><c> smart</c>

00:05:07.869 --> 00:05:07.879 align:start position:0%
input and if it outputs this empty smart
 

00:05:07.879 --> 00:05:10.269 align:start position:0%
input and if it outputs this empty smart
contract<00:05:08.300><c> then</c><00:05:08.590><c> the</c><00:05:09.590><c> input</c><00:05:09.740><c> halts</c><00:05:10.129><c> on</c><00:05:10.189><c> all</c>

00:05:10.269 --> 00:05:10.279 align:start position:0%
contract then the input halts on all
 

00:05:10.279 --> 00:05:12.999 align:start position:0%
contract then the input halts on all
inputs<00:05:10.340><c> and</c><00:05:10.759><c> otherwise</c><00:05:10.969><c> not</c><00:05:11.710><c> okay</c><00:05:12.710><c> that's</c><00:05:12.860><c> a</c>

00:05:12.999 --> 00:05:13.009 align:start position:0%
inputs and otherwise not okay that's a
 

00:05:13.009 --> 00:05:15.429 align:start position:0%
inputs and otherwise not okay that's a
nice<00:05:13.159><c> theoretical</c><00:05:13.729><c> result</c><00:05:14.000><c> but</c><00:05:14.439><c> yeah</c>

00:05:15.429 --> 00:05:15.439 align:start position:0%
nice theoretical result but yeah
 

00:05:15.439 --> 00:05:17.529 align:start position:0%
nice theoretical result but yeah
completely<00:05:16.099><c> useless</c><00:05:16.250><c> for</c><00:05:16.460><c> practice</c><00:05:17.330><c> I</c><00:05:17.479><c> mean</c>

00:05:17.529 --> 00:05:17.539 align:start position:0%
completely useless for practice I mean
 

00:05:17.539 --> 00:05:21.999 align:start position:0%
completely useless for practice I mean
it's<00:05:18.110><c> nice</c><00:05:18.289><c> to</c><00:05:18.620><c> know</c><00:05:19.300><c> the</c><00:05:20.300><c> lower</c><00:05:21.259><c> bounds</c><00:05:21.800><c> and</c>

00:05:21.999 --> 00:05:22.009 align:start position:0%
it's nice to know the lower bounds and
 

00:05:22.009 --> 00:05:24.989 align:start position:0%
it's nice to know the lower bounds and
where<00:05:22.370><c> we</c><00:05:22.490><c> cannot</c><00:05:22.759><c> go</c><00:05:23.029><c> but</c><00:05:23.689><c> if</c><00:05:23.810><c> we</c><00:05:23.900><c> relax</c><00:05:24.169><c> this</c>

00:05:24.989 --> 00:05:24.999 align:start position:0%
where we cannot go but if we relax this
 

00:05:24.999 --> 00:05:29.939 align:start position:0%
where we cannot go but if we relax this
optimal<00:05:25.999><c> thing</c><00:05:26.270><c> we</c><00:05:26.539><c> can</c><00:05:26.779><c> get</c><00:05:26.979><c> quite</c><00:05:27.979><c> far</c><00:05:28.250><c> so</c>

00:05:29.939 --> 00:05:29.949 align:start position:0%
optimal thing we can get quite far so
 

00:05:29.949 --> 00:05:32.559 align:start position:0%
optimal thing we can get quite far so
now<00:05:30.949><c> next</c><00:05:31.159><c> question</c><00:05:31.550><c> you</c><00:05:31.580><c> might</c><00:05:31.669><c> ask</c><00:05:31.819><c> is</c><00:05:32.240><c> why</c>

00:05:32.559 --> 00:05:32.569 align:start position:0%
now next question you might ask is why
 

00:05:32.569 --> 00:05:34.570 align:start position:0%
now next question you might ask is why
do<00:05:32.629><c> we</c><00:05:32.930><c> want</c><00:05:33.110><c> an</c><00:05:33.229><c> optimizer</c><00:05:33.650><c> and</c><00:05:33.860><c> there</c><00:05:34.069><c> is</c>

00:05:34.570 --> 00:05:34.580 align:start position:0%
do we want an optimizer and there is
 

00:05:34.580 --> 00:05:37.300 align:start position:0%
do we want an optimizer and there is
probably<00:05:35.360><c> an</c><00:05:35.689><c> obvious</c><00:05:36.080><c> answer</c><00:05:36.289><c> and</c><00:05:37.099><c> that</c><00:05:37.279><c> is</c>

00:05:37.300 --> 00:05:37.310 align:start position:0%
probably an obvious answer and that is
 

00:05:37.310 --> 00:05:39.670 align:start position:0%
probably an obvious answer and that is
we<00:05:37.580><c> want</c><00:05:37.610><c> cheaper</c><00:05:38.150><c> smart</c><00:05:38.389><c> contracts</c><00:05:38.810><c> but</c><00:05:39.439><c> if</c>

00:05:39.670 --> 00:05:39.680 align:start position:0%
we want cheaper smart contracts but if
 

00:05:39.680 --> 00:05:42.820 align:start position:0%
we want cheaper smart contracts but if
you<00:05:39.800><c> take</c><00:05:40.159><c> a</c><00:05:40.189><c> closer</c><00:05:40.490><c> look</c><00:05:40.639><c> then</c><00:05:40.939><c> this</c><00:05:41.180><c> is</c><00:05:41.830><c> not</c>

00:05:42.820 --> 00:05:42.830 align:start position:0%
you take a closer look then this is not
 

00:05:42.830 --> 00:05:45.269 align:start position:0%
you take a closer look then this is not
the<00:05:43.069><c> main</c><00:05:43.279><c> reason</c><00:05:43.310><c> to</c><00:05:43.819><c> have</c><00:05:43.939><c> an</c><00:05:44.089><c> optimizer</c>

00:05:45.269 --> 00:05:45.279 align:start position:0%
the main reason to have an optimizer
 

00:05:45.279 --> 00:05:49.420 align:start position:0%
the main reason to have an optimizer
instead<00:05:46.539><c> an</c><00:05:47.539><c> optimizer</c><00:05:48.020><c> allows</c><00:05:48.319><c> you</c><00:05:48.589><c> to</c><00:05:48.800><c> write</c>

00:05:49.420 --> 00:05:49.430 align:start position:0%
instead an optimizer allows you to write
 

00:05:49.430 --> 00:05:51.429 align:start position:0%
instead an optimizer allows you to write
your<00:05:49.699><c> code</c><00:05:49.969><c> in</c><00:05:50.210><c> a</c><00:05:50.300><c> more</c><00:05:50.509><c> modular</c><00:05:50.960><c> and</c><00:05:51.169><c> more</c>

00:05:51.429 --> 00:05:51.439 align:start position:0%
your code in a more modular and more
 

00:05:51.439 --> 00:05:55.540 align:start position:0%
your code in a more modular and more
understandable<00:05:52.159><c> way</c><00:05:52.310><c> so</c><00:05:53.139><c> if</c><00:05:54.139><c> you</c><00:05:54.830><c> do</c><00:05:55.159><c> not</c><00:05:55.310><c> use</c>

00:05:55.540 --> 00:05:55.550 align:start position:0%
understandable way so if you do not use
 

00:05:55.550 --> 00:05:58.450 align:start position:0%
understandable way so if you do not use
an<00:05:55.699><c> optimizer</c><00:05:56.120><c> and</c><00:05:56.479><c> you're</c><00:05:57.409><c> you</c><00:05:57.949><c> care</c><00:05:58.219><c> about</c>

00:05:58.450 --> 00:05:58.460 align:start position:0%
an optimizer and you're you care about
 

00:05:58.460 --> 00:05:59.950 align:start position:0%
an optimizer and you're you care about
resource<00:05:58.759><c> consumption</c><00:05:59.120><c> and</c><00:05:59.360><c> you</c><00:05:59.419><c> always</c><00:05:59.629><c> have</c>

00:05:59.950 --> 00:05:59.960 align:start position:0%
resource consumption and you always have
 

00:05:59.960 --> 00:06:02.829 align:start position:0%
resource consumption and you always have
to<00:06:00.189><c> consider</c><00:06:01.189><c> oh</c><00:06:01.580><c> is</c><00:06:01.789><c> this</c><00:06:02.000><c> is</c><00:06:02.300><c> this</c><00:06:02.569><c> cheap</c>

00:06:02.829 --> 00:06:02.839 align:start position:0%
to consider oh is this is this cheap
 

00:06:02.839 --> 00:06:04.899 align:start position:0%
to consider oh is this is this cheap
enough<00:06:03.050><c> what</c><00:06:03.259><c> I'm</c><00:06:03.349><c> writing</c><00:06:03.500><c> here</c><00:06:03.830><c> or</c><00:06:03.979><c> not</c><00:06:04.159><c> can</c>

00:06:04.899 --> 00:06:04.909 align:start position:0%
enough what I'm writing here or not can
 

00:06:04.909 --> 00:06:07.689 align:start position:0%
enough what I'm writing here or not can
I<00:06:05.000><c> change</c><00:06:05.330><c> it</c><00:06:05.569><c> in</c><00:06:05.930><c> a</c><00:06:06.349><c> way</c><00:06:06.379><c> so</c><00:06:06.620><c> that</c><00:06:06.919><c> it's</c><00:06:07.219><c> it's</c><00:06:07.610><c> a</c>

00:06:07.689 --> 00:06:07.699 align:start position:0%
I change it in a way so that it's it's a
 

00:06:07.699 --> 00:06:09.399 align:start position:0%
I change it in a way so that it's it's a
little<00:06:07.909><c> bit</c><00:06:08.029><c> cheaper</c><00:06:08.210><c> and</c><00:06:08.539><c> still</c><00:06:09.169><c> that's</c><00:06:09.289><c> the</c>

00:06:09.399 --> 00:06:09.409 align:start position:0%
little bit cheaper and still that's the
 

00:06:09.409 --> 00:06:11.920 align:start position:0%
little bit cheaper and still that's the
same<00:06:09.589><c> thing</c><00:06:09.800><c> and</c><00:06:10.180><c> but</c><00:06:11.180><c> if</c><00:06:11.300><c> you</c><00:06:11.389><c> know</c><00:06:11.539><c> that</c><00:06:11.779><c> the</c>

00:06:11.920 --> 00:06:11.930 align:start position:0%
same thing and but if you know that the
 

00:06:11.930 --> 00:06:13.540 align:start position:0%
same thing and but if you know that the
optimizer<00:06:12.319><c> will</c><00:06:12.500><c> just</c><00:06:12.649><c> do</c><00:06:12.770><c> that</c><00:06:12.889><c> for</c><00:06:13.129><c> yourself</c>

00:06:13.540 --> 00:06:13.550 align:start position:0%
optimizer will just do that for yourself
 

00:06:13.550 --> 00:06:16.240 align:start position:0%
optimizer will just do that for yourself
then<00:06:14.240><c> you</c><00:06:15.080><c> can</c><00:06:15.289><c> write</c><00:06:15.710><c> it</c><00:06:15.740><c> so</c><00:06:16.009><c> that</c><00:06:16.039><c> it's</c>

00:06:16.240 --> 00:06:16.250 align:start position:0%
then you can write it so that it's
 

00:06:16.250 --> 00:06:19.990 align:start position:0%
then you can write it so that it's
readable<00:06:16.669><c> it's</c><00:06:17.149><c> auditable</c><00:06:17.779><c> you</c><00:06:18.379><c> are</c><00:06:19.000><c> 100%</c>

00:06:19.990 --> 00:06:20.000 align:start position:0%
readable it's auditable you are 100%
 

00:06:20.000 --> 00:06:22.300 align:start position:0%
readable it's auditable you are 100%
sure<00:06:20.089><c> that</c><00:06:20.120><c> it</c><00:06:20.389><c> works</c><00:06:20.629><c> and</c><00:06:20.930><c> you</c><00:06:21.710><c> don't</c><00:06:22.009><c> have</c><00:06:22.159><c> to</c>

00:06:22.300 --> 00:06:22.310 align:start position:0%
sure that it works and you don't have to
 

00:06:22.310 --> 00:06:23.619 align:start position:0%
sure that it works and you don't have to
care<00:06:22.520><c> about</c><00:06:22.669><c> the</c><00:06:22.939><c> resource</c><00:06:23.149><c> consumption</c><00:06:23.449><c> all</c>

00:06:23.619 --> 00:06:23.629 align:start position:0%
care about the resource consumption all
 

00:06:23.629 --> 00:06:25.990 align:start position:0%
care about the resource consumption all
the<00:06:23.719><c> time</c><00:06:23.899><c> and</c><00:06:24.169><c> an</c><00:06:24.800><c> example</c><00:06:25.069><c> of</c><00:06:25.250><c> that</c><00:06:25.310><c> is</c><00:06:25.639><c> this</c>

00:06:25.990 --> 00:06:26.000 align:start position:0%
the time and an example of that is this
 

00:06:26.000 --> 00:06:30.659 align:start position:0%
the time and an example of that is this
smart<00:06:26.270><c> contract</c><00:06:26.750><c> here</c><00:06:28.899><c> it's</c><00:06:29.899><c> a</c><00:06:30.139><c> simple</c>

00:06:30.659 --> 00:06:30.669 align:start position:0%
smart contract here it's a simple
 

00:06:30.669 --> 00:06:32.980 align:start position:0%
smart contract here it's a simple
fragment<00:06:31.669><c> of</c><00:06:31.729><c> a</c><00:06:31.819><c> voting</c><00:06:32.000><c> contract</c><00:06:32.569><c> we</c><00:06:32.810><c> have</c><00:06:32.959><c> a</c>

00:06:32.980 --> 00:06:32.990 align:start position:0%
fragment of a voting contract we have a
 

00:06:32.990 --> 00:06:35.670 align:start position:0%
fragment of a voting contract we have a
vote<00:06:33.440><c> function</c><00:06:34.009><c> which</c><00:06:34.279><c> takes</c><00:06:34.519><c> an</c><00:06:34.699><c> output</c>

00:06:35.670 --> 00:06:35.680 align:start position:0%
vote function which takes an output
 

00:06:35.680 --> 00:06:38.670 align:start position:0%
vote function which takes an output
and<00:06:35.770><c> an</c><00:06:35.979><c> outcome</c><00:06:36.190><c> we</c><00:06:36.610><c> want</c><00:06:36.669><c> to</c><00:06:36.880><c> vote</c><00:06:37.030><c> and</c><00:06:37.680><c> it</c>

00:06:38.670 --> 00:06:38.680 align:start position:0%
and an outcome we want to vote and it
 

00:06:38.680 --> 00:06:40.999 align:start position:0%
and an outcome we want to vote and it
checks<00:06:38.919><c> that</c><00:06:39.190><c> the</c><00:06:39.400><c> user</c><00:06:39.580><c> has</c><00:06:39.850><c> not</c><00:06:39.880><c> voted</c><00:06:40.150><c> yet</c>

00:06:40.999 --> 00:06:41.009 align:start position:0%
checks that the user has not voted yet
 

00:06:41.009 --> 00:06:44.850 align:start position:0%
checks that the user has not voted yet
and<00:06:42.009><c> it</c><00:06:42.970><c> if</c><00:06:43.479><c> the</c><00:06:43.690><c> user</c><00:06:43.840><c> hasn't</c><00:06:44.080><c> voted</c><00:06:44.350><c> yet</c><00:06:44.560><c> it</c>

00:06:44.850 --> 00:06:44.860 align:start position:0%
and it if the user hasn't voted yet it
 

00:06:44.860 --> 00:06:47.879 align:start position:0%
and it if the user hasn't voted yet it
assigns<00:06:45.160><c> the</c><00:06:45.520><c> weight</c><00:06:45.910><c> of</c><00:06:46.300><c> the</c><00:06:46.690><c> user</c><00:06:46.900><c> to</c><00:06:47.080><c> the</c>

00:06:47.879 --> 00:06:47.889 align:start position:0%
assigns the weight of the user to the
 

00:06:47.889 --> 00:06:49.980 align:start position:0%
assigns the weight of the user to the
votes<00:06:48.130><c> and</c><00:06:48.430><c> you</c><00:06:49.120><c> see</c><00:06:49.270><c> that</c><00:06:49.360><c> this</c><00:06:49.509><c> weight</c><00:06:49.750><c> off</c>

00:06:49.980 --> 00:06:49.990 align:start position:0%
votes and you see that this weight off
 

00:06:49.990 --> 00:06:51.659 align:start position:0%
votes and you see that this weight off
is<00:06:50.229><c> another</c><00:06:50.470><c> function</c><00:06:50.710><c> that</c><00:06:51.070><c> just</c><00:06:51.310><c> returns</c>

00:06:51.659 --> 00:06:51.669 align:start position:0%
is another function that just returns
 

00:06:51.669 --> 00:06:53.850 align:start position:0%
is another function that just returns
ten<00:06:52.150><c> for</c><00:06:52.330><c> the</c><00:06:52.389><c> owner</c><00:06:52.539><c> and</c><00:06:52.990><c> one</c><00:06:53.410><c> for</c><00:06:53.590><c> everyone</c>

00:06:53.850 --> 00:06:53.860 align:start position:0%
ten for the owner and one for everyone
 

00:06:53.860 --> 00:06:59.400 align:start position:0%
ten for the owner and one for everyone
else<00:06:54.039><c> and</c><00:06:56.759><c> without</c><00:06:57.759><c> an</c><00:06:58.060><c> optimizer</c><00:06:58.449><c> this</c><00:06:59.169><c> would</c>

00:06:59.400 --> 00:06:59.410 align:start position:0%
else and without an optimizer this would
 

00:06:59.410 --> 00:07:01.890 align:start position:0%
else and without an optimizer this would
perform<00:06:59.949><c> a</c><00:07:00.039><c> function</c><00:07:00.370><c> call</c><00:07:00.550><c> which</c><00:07:00.850><c> is</c><00:07:01.030><c> costly</c>

00:07:01.890 --> 00:07:01.900 align:start position:0%
perform a function call which is costly
 

00:07:01.900 --> 00:07:05.879 align:start position:0%
perform a function call which is costly
so<00:07:02.380><c> a</c><00:07:03.509><c> cheaper</c><00:07:04.509><c> way</c><00:07:04.690><c> would</c><00:07:04.900><c> be</c><00:07:04.930><c> to</c><00:07:05.259><c> just</c><00:07:05.470><c> take</c>

00:07:05.879 --> 00:07:05.889 align:start position:0%
so a cheaper way would be to just take
 

00:07:05.889 --> 00:07:08.339 align:start position:0%
so a cheaper way would be to just take
this<00:07:06.130><c> this</c><00:07:07.000><c> this</c><00:07:07.300><c> statement</c><00:07:07.539><c> that</c><00:07:07.840><c> is</c><00:07:07.930><c> inside</c>

00:07:08.339 --> 00:07:08.349 align:start position:0%
this this this statement that is inside
 

00:07:08.349 --> 00:07:10.110 align:start position:0%
this this this statement that is inside
the<00:07:08.500><c> function</c><00:07:08.680><c> and</c><00:07:08.949><c> put</c><00:07:09.160><c> it</c><00:07:09.310><c> at</c><00:07:09.699><c> the</c><00:07:09.849><c> point</c><00:07:09.970><c> of</c>

00:07:10.110 --> 00:07:10.120 align:start position:0%
the function and put it at the point of
 

00:07:10.120 --> 00:07:12.839 align:start position:0%
the function and put it at the point of
the<00:07:10.210><c> function</c><00:07:10.360><c> call</c><00:07:10.690><c> but</c><00:07:11.530><c> that</c><00:07:11.680><c> will</c><00:07:11.919><c> yeah</c>

00:07:12.839 --> 00:07:12.849 align:start position:0%
the function call but that will yeah
 

00:07:12.849 --> 00:07:15.900 align:start position:0%
the function call but that will yeah
that<00:07:13.060><c> will</c><00:07:13.240><c> reduce</c><00:07:13.690><c> readability</c><00:07:14.370><c> it</c><00:07:15.370><c> will</c><00:07:15.729><c> not</c>

00:07:15.900 --> 00:07:15.910 align:start position:0%
that will reduce readability it will not
 

00:07:15.910 --> 00:07:18.360 align:start position:0%
that will reduce readability it will not
tell<00:07:16.120><c> you</c><00:07:16.300><c> what</c><00:07:16.509><c> this</c><00:07:16.720><c> weird</c><00:07:17.289><c> expression</c><00:07:17.889><c> 10:1</c>

00:07:18.360 --> 00:07:18.370 align:start position:0%
tell you what this weird expression 10:1
 

00:07:18.370 --> 00:07:20.820 align:start position:0%
tell you what this weird expression 10:1
actually<00:07:18.759><c> is</c><00:07:18.910><c> now</c><00:07:19.169><c> in</c><00:07:20.169><c> the</c><00:07:20.500><c> way</c><00:07:20.590><c> it's</c><00:07:20.710><c> written</c>

00:07:20.820 --> 00:07:20.830 align:start position:0%
actually is now in the way it's written
 

00:07:20.830 --> 00:07:23.070 align:start position:0%
actually is now in the way it's written
now<00:07:20.979><c> we</c><00:07:21.099><c> see</c><00:07:21.430><c> yes</c><00:07:21.639><c> the</c><00:07:21.849><c> weight</c><00:07:22.000><c> of</c><00:07:22.270><c> the</c><00:07:22.599><c> vote</c>

00:07:23.070 --> 00:07:23.080 align:start position:0%
now we see yes the weight of the vote
 

00:07:23.080 --> 00:07:27.029 align:start position:0%
now we see yes the weight of the vote
and<00:07:24.150><c> also</c><00:07:25.150><c> if</c><00:07:25.270><c> we</c><00:07:25.419><c> use</c><00:07:25.570><c> this</c><00:07:25.780><c> weight</c><00:07:26.080><c> if</c><00:07:26.710><c> it's</c>

00:07:27.029 --> 00:07:27.039 align:start position:0%
and also if we use this weight if it's
 

00:07:27.039 --> 00:07:28.320 align:start position:0%
and also if we use this weight if it's
like<00:07:27.190><c> that</c><00:07:27.370><c> we</c><00:07:27.520><c> can</c><00:07:27.669><c> use</c><00:07:27.789><c> the</c><00:07:27.940><c> function</c><00:07:28.240><c> from</c>

00:07:28.320 --> 00:07:28.330 align:start position:0%
like that we can use the function from
 

00:07:28.330 --> 00:07:30.089 align:start position:0%
like that we can use the function from
other<00:07:28.509><c> places</c><00:07:28.780><c> and</c><00:07:29.169><c> then</c><00:07:29.349><c> modify</c><00:07:29.680><c> the</c><00:07:29.860><c> weights</c>

00:07:30.089 --> 00:07:30.099 align:start position:0%
other places and then modify the weights
 

00:07:30.099 --> 00:07:31.860 align:start position:0%
other places and then modify the weights
without<00:07:30.280><c> having</c><00:07:30.669><c> to</c><00:07:30.759><c> modify</c><00:07:31.090><c> it</c><00:07:31.150><c> everywhere</c>

00:07:31.860 --> 00:07:31.870 align:start position:0%
without having to modify it everywhere
 

00:07:31.870 --> 00:07:36.540 align:start position:0%
without having to modify it everywhere
in<00:07:31.990><c> the</c><00:07:32.080><c> code</c><00:07:34.050><c> okay</c><00:07:35.050><c> in</c><00:07:35.860><c> the</c><00:07:35.949><c> rest</c><00:07:36.099><c> of</c><00:07:36.190><c> the</c><00:07:36.310><c> talk</c>

00:07:36.540 --> 00:07:36.550 align:start position:0%
in the code okay in the rest of the talk
 

00:07:36.550 --> 00:07:41.189 align:start position:0%
in the code okay in the rest of the talk
I<00:07:37.830><c> will</c><00:07:38.830><c> quickly</c><00:07:39.370><c> describe</c><00:07:39.880><c> how</c><00:07:40.599><c> the</c><00:07:40.659><c> current</c>

00:07:41.189 --> 00:07:41.199 align:start position:0%
I will quickly describe how the current
 

00:07:41.199 --> 00:07:43.760 align:start position:0%
I will quickly describe how the current
solidity<00:07:41.919><c> optimizer</c><00:07:42.370><c> works</c><00:07:42.639><c> and</c><00:07:42.970><c> then</c>

00:07:43.760 --> 00:07:43.770 align:start position:0%
solidity optimizer works and then
 

00:07:43.770 --> 00:07:51.750 align:start position:0%
solidity optimizer works and then
explain<00:07:44.770><c> what</c><00:07:45.550><c> we</c><00:07:45.729><c> plan</c><00:07:46.000><c> to</c><00:07:46.780><c> do</c><00:07:46.990><c> on</c><00:07:47.409><c> you'll</c><00:07:50.760><c> the</c>

00:07:51.750 --> 00:07:51.760 align:start position:0%
explain what we plan to do on you'll the
 

00:07:51.760 --> 00:07:56.100 align:start position:0%
explain what we plan to do on you'll the
current<00:07:52.479><c> optimizer</c><00:07:53.050><c> is</c><00:07:54.000><c> wholly</c><00:07:55.000><c> based</c><00:07:55.300><c> on</c><00:07:55.630><c> up</c>

00:07:56.100 --> 00:07:56.110 align:start position:0%
current optimizer is wholly based on up
 

00:07:56.110 --> 00:07:59.600 align:start position:0%
current optimizer is wholly based on up
code<00:07:56.409><c> stream</c><00:07:56.710><c> so</c><00:07:56.889><c> it's</c><00:07:57.039><c> extremely</c><00:07:57.220><c> low-level</c>

00:07:59.600 --> 00:07:59.610 align:start position:0%
code stream so it's extremely low-level
 

00:07:59.610 --> 00:08:03.000 align:start position:0%
code stream so it's extremely low-level
yeah<00:08:00.610><c> it</c><00:08:00.699><c> has</c><00:08:00.880><c> several</c><00:08:01.150><c> stages</c><00:08:01.539><c> I</c><00:08:02.229><c> won't</c><00:08:02.860><c> go</c>

00:08:03.000 --> 00:08:03.010 align:start position:0%
yeah it has several stages I won't go
 

00:08:03.010 --> 00:08:05.879 align:start position:0%
yeah it has several stages I won't go
into<00:08:03.159><c> detail</c><00:08:03.580><c> for</c><00:08:03.970><c> all</c><00:08:04.479><c> of</c><00:08:04.599><c> them</c><00:08:04.780><c> the</c><00:08:05.530><c> most</c>

00:08:05.879 --> 00:08:05.889 align:start position:0%
into detail for all of them the most
 

00:08:05.889 --> 00:08:07.890 align:start position:0%
into detail for all of them the most
extensive<00:08:06.400><c> stage</c><00:08:06.909><c> is</c><00:08:07.090><c> the</c><00:08:07.180><c> last</c><00:08:07.360><c> one</c><00:08:07.539><c> here</c><00:08:07.750><c> the</c>

00:08:07.890 --> 00:08:07.900 align:start position:0%
extensive stage is the last one here the
 

00:08:07.900 --> 00:08:09.510 align:start position:0%
extensive stage is the last one here the
common<00:08:08.139><c> sub-expression</c><00:08:08.680><c> Eliminator</c><00:08:09.190><c> which</c>

00:08:09.510 --> 00:08:09.520 align:start position:0%
common sub-expression Eliminator which
 

00:08:09.520 --> 00:08:12.450 align:start position:0%
common sub-expression Eliminator which
does<00:08:10.270><c> much</c><00:08:10.659><c> more</c><00:08:10.690><c> than</c><00:08:11.229><c> what</c><00:08:12.130><c> the</c><00:08:12.280><c> name</c>

00:08:12.450 --> 00:08:12.460 align:start position:0%
does much more than what the name
 

00:08:12.460 --> 00:08:17.760 align:start position:0%
does much more than what the name
suggests<00:08:12.940><c> and</c><00:08:14.520><c> yeah</c><00:08:15.520><c> let's</c><00:08:16.320><c> dive</c><00:08:17.320><c> into</c><00:08:17.530><c> that</c><00:08:17.740><c> a</c>

00:08:17.760 --> 00:08:17.770 align:start position:0%
suggests and yeah let's dive into that a
 

00:08:17.770 --> 00:08:20.490 align:start position:0%
suggests and yeah let's dive into that a
little<00:08:17.949><c> so</c><00:08:18.820><c> what</c><00:08:19.030><c> it</c><00:08:19.120><c> does</c><00:08:19.270><c> is</c><00:08:19.479><c> first</c><00:08:19.960><c> it</c><00:08:20.229><c> chops</c>

00:08:20.490 --> 00:08:20.500 align:start position:0%
little so what it does is first it chops
 

00:08:20.500 --> 00:08:23.010 align:start position:0%
little so what it does is first it chops
code<00:08:20.860><c> so</c><00:08:21.310><c> it</c><00:08:21.400><c> gets</c><00:08:21.789><c> a</c><00:08:21.909><c> stream</c><00:08:22.240><c> of</c><00:08:22.389><c> op</c><00:08:22.509><c> codes</c><00:08:22.780><c> and</c>

00:08:23.010 --> 00:08:23.020 align:start position:0%
code so it gets a stream of op codes and
 

00:08:23.020 --> 00:08:25.499 align:start position:0%
code so it gets a stream of op codes and
chops<00:08:23.259><c> that</c><00:08:23.380><c> into</c><00:08:23.830><c> blocks</c><00:08:24.639><c> blocks</c><00:08:25.240><c> that</c><00:08:25.389><c> don't</c>

00:08:25.499 --> 00:08:25.509 align:start position:0%
chops that into blocks blocks that don't
 

00:08:25.509 --> 00:08:28.050 align:start position:0%
chops that into blocks blocks that don't
contain<00:08:25.930><c> jumps</c><00:08:26.800><c> don't</c><00:08:27.159><c> contain</c><00:08:27.490><c> external</c>

00:08:28.050 --> 00:08:28.060 align:start position:0%
contain jumps don't contain external
 

00:08:28.060 --> 00:08:30.899 align:start position:0%
contain jumps don't contain external
calls<00:08:28.300><c> and</c><00:08:28.599><c> some</c><00:08:28.810><c> other</c><00:08:28.960><c> restrictions</c><00:08:29.909><c> then</c>

00:08:30.899 --> 00:08:30.909 align:start position:0%
calls and some other restrictions then
 

00:08:30.909 --> 00:08:34.139 align:start position:0%
calls and some other restrictions then
these<00:08:31.469><c> blocks</c><00:08:32.469><c> are</c><00:08:32.740><c> fed</c><00:08:33.039><c> up</c><00:08:33.279><c> code</c><00:08:33.880><c> the</c><00:08:34.000><c> OP</c><00:08:34.120><c> code</c>

00:08:34.139 --> 00:08:34.149 align:start position:0%
these blocks are fed up code the OP code
 

00:08:34.149 --> 00:08:36.659 align:start position:0%
these blocks are fed up code the OP code
to<00:08:34.510><c> the</c><00:08:34.630><c> component</c><00:08:35.169><c> the</c><00:08:35.649><c> comment</c><00:08:36.039><c> component</c>

00:08:36.659 --> 00:08:36.669 align:start position:0%
to the component the comment component
 

00:08:36.669 --> 00:08:39.180 align:start position:0%
to the component the comment component
builds<00:08:37.000><c> symbolic</c><00:08:37.779><c> expression</c><00:08:38.229><c> trees</c><00:08:38.469><c> so</c>

00:08:39.180 --> 00:08:39.190 align:start position:0%
builds symbolic expression trees so
 

00:08:39.190 --> 00:08:41.790 align:start position:0%
builds symbolic expression trees so
analyzes<00:08:39.729><c> the</c><00:08:39.849><c> stack</c><00:08:40.029><c> usage</c><00:08:40.419><c> and</c><00:08:40.800><c> creates</c>

00:08:41.790 --> 00:08:41.800 align:start position:0%
analyzes the stack usage and creates
 

00:08:41.800 --> 00:08:43.890 align:start position:0%
analyzes the stack usage and creates
symbolic<00:08:42.159><c> expressions</c><00:08:42.579><c> out</c><00:08:42.700><c> of</c><00:08:42.849><c> them</c><00:08:43.029><c> then</c>

00:08:43.890 --> 00:08:43.900 align:start position:0%
symbolic expressions out of them then
 

00:08:43.900 --> 00:08:46.500 align:start position:0%
symbolic expressions out of them then
these<00:08:44.500><c> expression</c><00:08:45.040><c> trees</c><00:08:45.220><c> are</c><00:08:45.430><c> simplified</c><00:08:46.180><c> to</c>

00:08:46.500 --> 00:08:46.510 align:start position:0%
these expression trees are simplified to
 

00:08:46.510 --> 00:08:49.619 align:start position:0%
these expression trees are simplified to
I<00:08:47.020><c> think</c><00:08:47.670><c> 40</c><00:08:48.670><c> or</c><00:08:48.820><c> 50</c>

00:08:49.619 --> 00:08:49.629 align:start position:0%
I think 40 or 50
 

00:08:49.629 --> 00:08:53.479 align:start position:0%
I think 40 or 50
simple<00:08:50.459><c> transformation</c><00:08:51.459><c> rules</c><00:08:51.699><c> like</c><00:08:52.350><c> yeah</c>

00:08:53.479 --> 00:08:53.489 align:start position:0%
simple transformation rules like yeah
 

00:08:53.489 --> 00:08:55.949 align:start position:0%
simple transformation rules like yeah
constant<00:08:54.489><c> plus</c><00:08:54.639><c> variable</c><00:08:55.029><c> plus</c><00:08:55.269><c> constant</c><00:08:55.600><c> is</c>

00:08:55.949 --> 00:08:55.959 align:start position:0%
constant plus variable plus constant is
 

00:08:55.959 --> 00:08:58.460 align:start position:0%
constant plus variable plus constant is
variable<00:08:56.739><c> plus</c><00:08:56.949><c> the</c><00:08:57.189><c> sum</c><00:08:57.399><c> of</c><00:08:57.429><c> the</c><00:08:57.610><c> constants</c>

00:08:58.460 --> 00:08:58.470 align:start position:0%
variable plus the sum of the constants
 

00:08:58.470 --> 00:09:02.340 align:start position:0%
variable plus the sum of the constants
and<00:08:59.470><c> so</c><00:08:59.649><c> on</c><00:09:00.149><c> these</c><00:09:01.149><c> rules</c><00:09:01.420><c> will</c><00:09:01.600><c> be</c><00:09:01.689><c> reused</c><00:09:02.110><c> by</c>

00:09:02.340 --> 00:09:02.350 align:start position:0%
and so on these rules will be reused by
 

00:09:02.350 --> 00:09:03.479 align:start position:0%
and so on these rules will be reused by
the<00:09:02.410><c> you'll</c><00:09:02.619><c> optimize</c><00:09:03.040><c> so</c><00:09:03.189><c> that's</c><00:09:03.369><c> not</c>

00:09:03.479 --> 00:09:03.489 align:start position:0%
the you'll optimize so that's not
 

00:09:03.489 --> 00:09:06.389 align:start position:0%
the you'll optimize so that's not
something<00:09:03.699><c> we</c><00:09:03.910><c> have</c><00:09:03.939><c> to</c><00:09:04.149><c> rewrite</c><00:09:04.480><c> and</c><00:09:05.399><c> after</c>

00:09:06.389 --> 00:09:06.399 align:start position:0%
something we have to rewrite and after
 

00:09:06.399 --> 00:09:09.929 align:start position:0%
something we have to rewrite and after
the<00:09:07.319><c> expression</c><00:09:08.319><c> fees</c><00:09:08.470><c> are</c><00:09:08.709><c> simplified</c><00:09:09.249><c> the</c>

00:09:09.929 --> 00:09:09.939 align:start position:0%
the expression fees are simplified the
 

00:09:09.939 --> 00:09:12.989 align:start position:0%
the expression fees are simplified the
component<00:09:10.509><c> records</c><00:09:11.439><c> all</c><00:09:12.009><c> changes</c><00:09:12.610><c> to</c><00:09:12.730><c> memory</c>

00:09:12.989 --> 00:09:12.999 align:start position:0%
component records all changes to memory
 

00:09:12.999 --> 00:09:15.090 align:start position:0%
component records all changes to memory
and<00:09:13.179><c> storage</c><00:09:13.389><c> in</c><00:09:13.689><c> an</c><00:09:13.779><c> abstract</c><00:09:14.049><c> way</c><00:09:14.379><c> so</c><00:09:14.649><c> both</c>

00:09:15.090 --> 00:09:15.100 align:start position:0%
and storage in an abstract way so both
 

00:09:15.100 --> 00:09:16.889 align:start position:0%
and storage in an abstract way so both
the<00:09:15.429><c> value</c><00:09:15.850><c> that</c><00:09:15.939><c> is</c><00:09:16.059><c> written</c><00:09:16.239><c> and</c><00:09:16.480><c> the</c><00:09:16.629><c> point</c>

00:09:16.889 --> 00:09:16.899 align:start position:0%
the value that is written and the point
 

00:09:16.899 --> 00:09:19.530 align:start position:0%
the value that is written and the point
where<00:09:17.379><c> it's</c><00:09:17.529><c> written</c><00:09:17.709><c> to</c><00:09:17.949><c> are</c><00:09:18.160><c> these</c><00:09:19.029><c> abstract</c>

00:09:19.530 --> 00:09:19.540 align:start position:0%
where it's written to are these abstract
 

00:09:19.540 --> 00:09:22.499 align:start position:0%
where it's written to are these abstract
expressions<00:09:20.790><c> yeah</c><00:09:21.790><c> the</c><00:09:22.089><c> problem</c><00:09:22.360><c> with</c><00:09:22.449><c> that</c>

00:09:22.499 --> 00:09:22.509 align:start position:0%
expressions yeah the problem with that
 

00:09:22.509 --> 00:09:25.889 align:start position:0%
expressions yeah the problem with that
is<00:09:22.809><c> that</c><00:09:23.189><c> it</c><00:09:24.189><c> kind</c><00:09:24.429><c> of</c><00:09:24.549><c> looks</c><00:09:24.790><c> like</c><00:09:24.910><c> this</c><00:09:25.209><c> so</c><00:09:25.569><c> on</c>

00:09:25.889 --> 00:09:25.899 align:start position:0%
is that it kind of looks like this so on
 

00:09:25.899 --> 00:09:27.689 align:start position:0%
is that it kind of looks like this so on
the<00:09:25.959><c> left</c><00:09:26.199><c> you</c><00:09:26.379><c> have</c><00:09:26.410><c> the</c><00:09:26.769><c> stream</c><00:09:27.129><c> of</c><00:09:27.249><c> opcodes</c>

00:09:27.689 --> 00:09:27.699 align:start position:0%
the left you have the stream of opcodes
 

00:09:27.699 --> 00:09:30.269 align:start position:0%
the left you have the stream of opcodes
and<00:09:27.970><c> on</c><00:09:28.119><c> the</c><00:09:28.209><c> right</c><00:09:28.420><c> you</c><00:09:29.290><c> have</c><00:09:29.319><c> some</c><00:09:29.470><c> kind</c><00:09:30.069><c> of</c>

00:09:30.269 --> 00:09:30.279 align:start position:0%
and on the right you have some kind of
 

00:09:30.279 --> 00:09:33.359 align:start position:0%
and on the right you have some kind of
explanation<00:09:31.209><c> of</c><00:09:31.720><c> what</c><00:09:32.139><c> the</c><00:09:32.350><c> component</c><00:09:33.009><c> has</c><00:09:33.100><c> to</c>

00:09:33.359 --> 00:09:33.369 align:start position:0%
explanation of what the component has to
 

00:09:33.369 --> 00:09:37.169 align:start position:0%
explanation of what the component has to
store<00:09:33.819><c> internally</c><00:09:34.769><c> in</c><00:09:35.769><c> the</c><00:09:35.980><c> end</c><00:09:36.249><c> we</c><00:09:36.369><c> can't</c><00:09:36.670><c> be</c>

00:09:37.169 --> 00:09:37.179 align:start position:0%
store internally in the end we can't be
 

00:09:37.179 --> 00:09:39.299 align:start position:0%
store internally in the end we can't be
yeah<00:09:37.689><c> there's</c><00:09:37.869><c> no</c><00:09:38.079><c> real</c><00:09:38.350><c> way</c><00:09:38.589><c> to</c><00:09:38.619><c> output</c><00:09:39.160><c> the</c>

00:09:39.299 --> 00:09:39.309 align:start position:0%
yeah there's no real way to output the
 

00:09:39.309 --> 00:09:41.189 align:start position:0%
yeah there's no real way to output the
internal<00:09:39.730><c> symbolic</c><00:09:40.239><c> representation</c><00:09:40.839><c> even</c><00:09:41.079><c> if</c>

00:09:41.189 --> 00:09:41.199 align:start position:0%
internal symbolic representation even if
 

00:09:41.199 --> 00:09:43.799 align:start position:0%
internal symbolic representation even if
there<00:09:41.559><c> was</c><00:09:41.920><c> such</c><00:09:42.160><c> a</c><00:09:42.189><c> way</c><00:09:42.489><c> it</c><00:09:43.329><c> would</c><00:09:43.540><c> be</c><00:09:43.660><c> very</c>

00:09:43.799 --> 00:09:43.809 align:start position:0%
there was such a way it would be very
 

00:09:43.809 --> 00:09:51.929 align:start position:0%
there was such a way it would be very
hard<00:09:44.079><c> to</c><00:09:44.230><c> read</c><00:09:45.059><c> and</c><00:09:49.170><c> yeah</c><00:09:50.170><c> so</c><00:09:50.790><c> yeah</c><00:09:51.790><c> the</c>

00:09:51.929 --> 00:09:51.939 align:start position:0%
hard to read and yeah so yeah the
 

00:09:51.939 --> 00:09:54.419 align:start position:0%
hard to read and yeah so yeah the
takeaway<00:09:52.420><c> from</c><00:09:53.019><c> the</c><00:09:53.170><c> old</c><00:09:53.319><c> CC</c><00:09:53.739><c> optimizer</c><00:09:54.129><c> is</c>

00:09:54.419 --> 00:09:54.429 align:start position:0%
takeaway from the old CC optimizer is
 

00:09:54.429 --> 00:09:57.059 align:start position:0%
takeaway from the old CC optimizer is
that<00:09:54.730><c> it</c><00:09:55.059><c> builds</c><00:09:55.419><c> a</c><00:09:55.779><c> gigantic</c><00:09:56.470><c> internal</c><00:09:56.919><c> data</c>

00:09:57.059 --> 00:09:57.069 align:start position:0%
that it builds a gigantic internal data
 

00:09:57.069 --> 00:10:04.859 align:start position:0%
that it builds a gigantic internal data
structure<00:09:57.549><c> yeah</c><00:09:59.279><c> yeah</c><00:10:01.350><c> and</c><00:10:03.689><c> after</c><00:10:04.689><c> it</c><00:10:04.749><c> has</c>

00:10:04.859 --> 00:10:04.869 align:start position:0%
structure yeah yeah and after it has
 

00:10:04.869 --> 00:10:07.650 align:start position:0%
structure yeah yeah and after it has
built<00:10:05.110><c> this</c><00:10:05.290><c> data</c><00:10:05.829><c> structure</c><00:10:06.160><c> it</c><00:10:06.660><c> regenerates</c>

00:10:07.650 --> 00:10:07.660 align:start position:0%
built this data structure it regenerates
 

00:10:07.660 --> 00:10:09.929 align:start position:0%
built this data structure it regenerates
the<00:10:07.779><c> code</c><00:10:08.079><c> from</c><00:10:08.439><c> scratch</c><00:10:08.619><c> so</c><00:10:09.220><c> it</c><00:10:09.429><c> starts</c><00:10:09.790><c> from</c>

00:10:09.929 --> 00:10:09.939 align:start position:0%
the code from scratch so it starts from
 

00:10:09.939 --> 00:10:14.519 align:start position:0%
the code from scratch so it starts from
the<00:10:10.059><c> bottom</c><00:10:10.179><c> up</c><00:10:10.480><c> and</c><00:10:12.779><c> takes</c><00:10:13.779><c> a</c><00:10:13.929><c> look</c><00:10:14.049><c> what</c><00:10:14.319><c> the</c>

00:10:14.519 --> 00:10:14.529 align:start position:0%
the bottom up and takes a look what the
 

00:10:14.529 --> 00:10:17.340 align:start position:0%
the bottom up and takes a look what the
desired<00:10:15.220><c> stack</c><00:10:15.879><c> elements</c><00:10:16.749><c> at</c><00:10:16.839><c> the</c><00:10:16.869><c> end</c><00:10:17.110><c> of</c>

00:10:17.340 --> 00:10:17.350 align:start position:0%
desired stack elements at the end of
 

00:10:17.350 --> 00:10:20.429 align:start position:0%
desired stack elements at the end of
this<00:10:17.529><c> chopped</c><00:10:18.429><c> up</c><00:10:18.579><c> block</c><00:10:18.970><c> would</c><00:10:19.600><c> be</c><00:10:19.629><c> then</c>

00:10:20.429 --> 00:10:20.439 align:start position:0%
this chopped up block would be then
 

00:10:20.439 --> 00:10:23.220 align:start position:0%
this chopped up block would be then
recreates<00:10:21.220><c> the</c><00:10:21.759><c> stack</c><00:10:22.089><c> elements</c><00:10:22.629><c> and</c><00:10:22.839><c> also</c>

00:10:23.220 --> 00:10:23.230 align:start position:0%
recreates the stack elements and also
 

00:10:23.230 --> 00:10:26.239 align:start position:0%
recreates the stack elements and also
recreates<00:10:24.220><c> changes</c><00:10:24.759><c> to</c><00:10:24.970><c> storage</c><00:10:25.419><c> and</c><00:10:25.660><c> memory</c>

00:10:26.239 --> 00:10:26.249 align:start position:0%
recreates changes to storage and memory
 

00:10:26.249 --> 00:10:30.359 align:start position:0%
recreates changes to storage and memory
in<00:10:27.249><c> a</c><00:10:27.489><c> more</c><00:10:27.699><c> efficient</c><00:10:28.059><c> way</c><00:10:28.230><c> because</c><00:10:29.230><c> it</c><00:10:30.220><c> will</c>

00:10:30.359 --> 00:10:30.369 align:start position:0%
in a more efficient way because it will
 

00:10:30.369 --> 00:10:33.299 align:start position:0%
in a more efficient way because it will
really<00:10:30.699><c> mean</c><00:10:30.790><c> a</c><00:10:31.029><c> limit</c><00:10:31.389><c> eliminate</c><00:10:32.309><c> multiple</c>

00:10:33.299 --> 00:10:33.309 align:start position:0%
really mean a limit eliminate multiple
 

00:10:33.309 --> 00:10:34.979 align:start position:0%
really mean a limit eliminate multiple
stores<00:10:33.549><c> to</c><00:10:33.819><c> the</c><00:10:33.850><c> same</c><00:10:34.089><c> storage</c><00:10:34.360><c> location</c><00:10:34.869><c> and</c>

00:10:34.979 --> 00:10:34.989 align:start position:0%
stores to the same storage location and
 

00:10:34.989 --> 00:10:36.359 align:start position:0%
stores to the same storage location and
multiple<00:10:35.319><c> memory</c><00:10:35.559><c> stores</c><00:10:35.919><c> to</c><00:10:36.100><c> the</c><00:10:36.160><c> same</c>

00:10:36.359 --> 00:10:36.369 align:start position:0%
multiple memory stores to the same
 

00:10:36.369 --> 00:10:39.929 align:start position:0%
multiple memory stores to the same
memory<00:10:36.639><c> location</c><00:10:36.699><c> and</c><00:10:37.299><c> also</c><00:10:38.230><c> if</c><00:10:38.439><c> you</c><00:10:38.589><c> have</c><00:10:39.369><c> if</c>

00:10:39.929 --> 00:10:39.939 align:start position:0%
memory location and also if you have if
 

00:10:39.939 --> 00:10:43.799 align:start position:0%
memory location and also if you have if
we<00:10:40.299><c> have</c><00:10:40.419><c> two</c><00:10:40.600><c> expressions</c><00:10:41.939><c> in</c><00:10:42.939><c> the</c><00:10:43.119><c> code</c><00:10:43.360><c> that</c>

00:10:43.799 --> 00:10:43.809 align:start position:0%
we have two expressions in the code that
 

00:10:43.809 --> 00:10:44.970 align:start position:0%
we have two expressions in the code that
do<00:10:43.929><c> the</c><00:10:44.019><c> same</c><00:10:44.199><c> thing</c><00:10:44.410><c> then</c><00:10:44.589><c> it's</c><00:10:44.829><c> only</c>

00:10:44.970 --> 00:10:44.980 align:start position:0%
do the same thing then it's only
 

00:10:44.980 --> 00:10:48.720 align:start position:0%
do the same thing then it's only
computed<00:10:45.399><c> once</c><00:10:46.980><c> and</c><00:10:47.980><c> yeah</c><00:10:48.279><c> as</c><00:10:48.369><c> I</c><00:10:48.459><c> said</c><00:10:48.519><c> the</c>

00:10:48.720 --> 00:10:48.730 align:start position:0%
computed once and yeah as I said the
 

00:10:48.730 --> 00:10:50.549 align:start position:0%
computed once and yeah as I said the
main<00:10:48.850><c> drawback</c><00:10:49.209><c> of</c><00:10:49.299><c> this</c><00:10:49.480><c> component</c><00:10:50.290><c> is</c><00:10:50.350><c> very</c>

00:10:50.549 --> 00:10:50.559 align:start position:0%
main drawback of this component is very
 

00:10:50.559 --> 00:10:55.159 align:start position:0%
main drawback of this component is very
opaque<00:10:52.559><c> also</c><00:10:53.559><c> it</c><00:10:53.649><c> is</c><00:10:53.799><c> only</c><00:10:53.980><c> very</c><00:10:54.189><c> local</c>

00:10:55.159 --> 00:10:55.169 align:start position:0%
opaque also it is only very local
 

00:10:55.169 --> 00:10:59.159 align:start position:0%
opaque also it is only very local
optimizations<00:10:56.169><c> only</c><00:10:57.129><c> inside</c><00:10:57.669><c> these</c><00:10:58.169><c> blocks</c>

00:10:59.159 --> 00:10:59.169 align:start position:0%
optimizations only inside these blocks
 

00:10:59.169 --> 00:11:02.519 align:start position:0%
optimizations only inside these blocks
it<00:10:59.919><c> has</c><00:11:00.279><c> no</c><00:11:01.240><c> notion</c><00:11:01.629><c> of</c><00:11:01.809><c> functions</c><00:11:02.350><c> so</c><00:11:02.470><c> it</c>

00:11:02.519 --> 00:11:02.529 align:start position:0%
it has no notion of functions so it
 

00:11:02.529 --> 00:11:03.070 align:start position:0%
it has no notion of functions so it
cannot

00:11:03.070 --> 00:11:03.080 align:start position:0%
cannot
 

00:11:03.080 --> 00:11:05.710 align:start position:0%
cannot
inlining<00:11:03.740><c> and</c><00:11:04.100><c> also</c><00:11:04.640><c> cannot</c><00:11:04.820><c> do</c><00:11:04.970><c> any</c><00:11:05.149><c> loop</c>

00:11:05.710 --> 00:11:05.720 align:start position:0%
inlining and also cannot do any loop
 

00:11:05.720 --> 00:11:09.820 align:start position:0%
inlining and also cannot do any loop
optimizations<00:11:06.470><c> there</c><00:11:06.950><c> are</c><00:11:07.100><c> some</c><00:11:08.680><c> stages</c><00:11:09.680><c> in</c>

00:11:09.820 --> 00:11:09.830 align:start position:0%
optimizations there are some stages in
 

00:11:09.830 --> 00:11:12.820 align:start position:0%
optimizations there are some stages in
the<00:11:09.920><c> old</c><00:11:10.040><c> optimizer</c><00:11:10.550><c> that</c><00:11:11.240><c> look</c><00:11:11.959><c> beyond</c><00:11:12.500><c> these</c>

00:11:12.820 --> 00:11:12.830 align:start position:0%
the old optimizer that look beyond these
 

00:11:12.830 --> 00:11:18.180 align:start position:0%
the old optimizer that look beyond these
blocks<00:11:13.399><c> but</c><00:11:13.790><c> they</c><00:11:14.000><c> also</c><00:11:14.149><c> do</c><00:11:14.420><c> not</c><00:11:14.450><c> do</c><00:11:14.720><c> in</c><00:11:14.899><c> lining</c>

00:11:18.180 --> 00:11:18.190 align:start position:0%
 
 

00:11:18.190 --> 00:11:21.040 align:start position:0%
 
ok<00:11:19.190><c> now</c><00:11:19.370><c> let's</c><00:11:19.730><c> take</c><00:11:19.880><c> a</c><00:11:19.940><c> look</c><00:11:20.089><c> at</c><00:11:20.269><c> at</c><00:11:20.540><c> Yule</c><00:11:20.810><c> and</c>

00:11:21.040 --> 00:11:21.050 align:start position:0%
ok now let's take a look at at Yule and
 

00:11:21.050 --> 00:11:24.900 align:start position:0%
ok now let's take a look at at Yule and
what<00:11:21.350><c> the</c><00:11:21.529><c> new</c><00:11:21.680><c> optimizer</c><00:11:22.630><c> can</c><00:11:23.630><c> do</c><00:11:23.959><c> with</c><00:11:24.200><c> it</c>

00:11:24.900 --> 00:11:24.910 align:start position:0%
what the new optimizer can do with it
 

00:11:24.910 --> 00:11:27.310 align:start position:0%
what the new optimizer can do with it
there<00:11:25.910><c> has</c><00:11:26.240><c> been</c><00:11:26.390><c> a</c><00:11:26.450><c> talk</c><00:11:26.779><c> I</c><00:11:26.959><c> think</c><00:11:27.140><c> yesterday</c>

00:11:27.310 --> 00:11:27.320 align:start position:0%
there has been a talk I think yesterday
 

00:11:27.320 --> 00:11:30.160 align:start position:0%
there has been a talk I think yesterday
by<00:11:27.800><c> Alex</c><00:11:28.130><c> about</c><00:11:28.310><c> Yule</c><00:11:28.670><c> here</c><00:11:29.240><c> at</c><00:11:29.450><c> DEFCON</c><00:11:29.779><c> 4</c><00:11:30.019><c> and</c>

00:11:30.160 --> 00:11:30.170 align:start position:0%
by Alex about Yule here at DEFCON 4 and
 

00:11:30.170 --> 00:11:31.540 align:start position:0%
by Alex about Yule here at DEFCON 4 and
also<00:11:30.320><c> another</c><00:11:30.769><c> one</c><00:11:30.890><c> that</c><00:11:30.980><c> I've</c><00:11:31.130><c> confirmed</c>

00:11:31.540 --> 00:11:31.550 align:start position:0%
also another one that I've confirmed
 

00:11:31.550 --> 00:11:36.040 align:start position:0%
also another one that I've confirmed
last<00:11:31.760><c> year</c><00:11:33.430><c> we</c><00:11:34.430><c> are</c><00:11:34.610><c> already</c><00:11:34.940><c> using</c><00:11:35.269><c> Yule</c><00:11:35.779><c> in</c>

00:11:36.040 --> 00:11:36.050 align:start position:0%
last year we are already using Yule in
 

00:11:36.050 --> 00:11:40.319 align:start position:0%
last year we are already using Yule in
the<00:11:36.290><c> new</c><00:11:36.740><c> ABI</c><00:11:37.430><c> coder</c><00:11:37.880><c> and</c><00:11:38.230><c> the</c><00:11:39.230><c> plan</c><00:11:39.440><c> is</c><00:11:39.620><c> to</c><00:11:39.829><c> use</c>

00:11:40.319 --> 00:11:40.329 align:start position:0%
the new ABI coder and the plan is to use
 

00:11:40.329 --> 00:11:43.660 align:start position:0%
the new ABI coder and the plan is to use
Yule<00:11:41.329><c> for</c><00:11:41.540><c> everything</c><00:11:41.870><c> else</c><00:11:42.040><c> starting</c><00:11:43.040><c> next</c>

00:11:43.660 --> 00:11:43.670 align:start position:0%
Yule for everything else starting next
 

00:11:43.670 --> 00:11:47.019 align:start position:0%
Yule for everything else starting next
week<00:11:43.940><c> so</c><00:11:44.360><c> the</c><00:11:45.079><c> plan</c><00:11:45.350><c> is</c><00:11:45.380><c> to</c><00:11:45.640><c> rewrite</c><00:11:46.640><c> the</c><00:11:46.850><c> code</c>

00:11:47.019 --> 00:11:47.029 align:start position:0%
week so the plan is to rewrite the code
 

00:11:47.029 --> 00:11:49.780 align:start position:0%
week so the plan is to rewrite the code
generator<00:11:47.420><c> of</c><00:11:47.630><c> solidity</c><00:11:48.050><c> using</c><00:11:48.709><c> Yule</c><00:11:48.860><c> so</c><00:11:49.610><c> that</c>

00:11:49.780 --> 00:11:49.790 align:start position:0%
generator of solidity using Yule so that
 

00:11:49.790 --> 00:11:54.460 align:start position:0%
generator of solidity using Yule so that
it<00:11:49.970><c> can</c><00:11:50.950><c> target</c><00:11:51.950><c> both</c><00:11:52.820><c> EVM</c><00:11:53.420><c> and</c><00:11:53.750><c> web</c><00:11:53.990><c> assembly</c>

00:11:54.460 --> 00:11:54.470 align:start position:0%
it can target both EVM and web assembly
 

00:11:54.470 --> 00:11:57.280 align:start position:0%
it can target both EVM and web assembly
and<00:11:54.820><c> we</c><00:11:55.820><c> will</c><00:11:55.940><c> also</c><00:11:56.209><c> be</c><00:11:56.300><c> able</c><00:11:56.540><c> to</c><00:11:56.600><c> use</c><00:11:56.779><c> the</c>

00:11:57.280 --> 00:11:57.290 align:start position:0%
and we will also be able to use the
 

00:11:57.290 --> 00:12:00.130 align:start position:0%
and we will also be able to use the
optimizer<00:11:57.709><c> for</c><00:11:57.860><c> all</c><00:11:58.339><c> of</c><00:11:58.850><c> the</c><00:11:59.089><c> the</c><00:11:59.120><c> code</c><00:11:59.990><c> that</c>

00:12:00.130 --> 00:12:00.140 align:start position:0%
optimizer for all of the the code that
 

00:12:00.140 --> 00:12:02.440 align:start position:0%
optimizer for all of the the code that
solidity<00:12:00.470><c> generates</c><00:12:00.920><c> not</c><00:12:01.100><c> only</c><00:12:01.459><c> for</c><00:12:02.029><c> the</c><00:12:02.209><c> ABI</c>

00:12:02.440 --> 00:12:02.450 align:start position:0%
solidity generates not only for the ABI
 

00:12:02.450 --> 00:12:07.410 align:start position:0%
solidity generates not only for the ABI
coder<00:12:04.390><c> yeah</c><00:12:05.390><c> you'll</c><00:12:05.720><c> has</c><00:12:05.930><c> a</c><00:12:05.959><c> simple</c><00:12:06.649><c> syntax</c>

00:12:07.410 --> 00:12:07.420 align:start position:0%
coder yeah you'll has a simple syntax
 

00:12:07.420 --> 00:12:10.180 align:start position:0%
coder yeah you'll has a simple syntax
has<00:12:08.420><c> structural</c><00:12:08.870><c> components</c><00:12:09.529><c> and</c><00:12:09.740><c> I</c><00:12:09.920><c> think</c>

00:12:10.180 --> 00:12:10.190 align:start position:0%
has structural components and I think
 

00:12:10.190 --> 00:12:15.010 align:start position:0%
has structural components and I think
it's<00:12:11.170><c> quite</c><00:12:12.170><c> intuitive</c><00:12:12.529><c> to</c><00:12:12.920><c> read</c><00:12:13.720><c> but</c><00:12:14.720><c> yeah</c>

00:12:15.010 --> 00:12:15.020 align:start position:0%
it's quite intuitive to read but yeah
 

00:12:15.020 --> 00:12:17.079 align:start position:0%
it's quite intuitive to read but yeah
I'm<00:12:15.980><c> already</c><00:12:16.279><c> spending</c><00:12:16.640><c> too</c><00:12:16.730><c> much</c><00:12:16.790><c> time</c><00:12:16.940><c> on</c>

00:12:17.079 --> 00:12:17.089 align:start position:0%
I'm already spending too much time on
 

00:12:17.089 --> 00:12:19.510 align:start position:0%
I'm already spending too much time on
that<00:12:17.209><c> so</c><00:12:17.990><c> let's</c><00:12:18.589><c> take</c><00:12:18.800><c> a</c><00:12:18.829><c> look</c><00:12:18.980><c> what</c><00:12:19.160><c> the</c>

00:12:19.510 --> 00:12:19.520 align:start position:0%
that so let's take a look what the
 

00:12:19.520 --> 00:12:25.660 align:start position:0%
that so let's take a look what the
optimizer<00:12:20.270><c> itself</c><00:12:22.779><c> instead</c><00:12:23.779><c> of</c><00:12:24.550><c> building</c><00:12:25.550><c> a</c>

00:12:25.660 --> 00:12:25.670 align:start position:0%
optimizer itself instead of building a
 

00:12:25.670 --> 00:12:28.740 align:start position:0%
optimizer itself instead of building a
component<00:12:26.029><c> that</c><00:12:26.420><c> looks</c><00:12:27.140><c> at</c><00:12:27.560><c> the</c><00:12:28.010><c> code</c><00:12:28.220><c> and</c>

00:12:28.740 --> 00:12:28.750 align:start position:0%
component that looks at the code and
 

00:12:28.750 --> 00:12:31.960 align:start position:0%
component that looks at the code and
assembles<00:12:29.750><c> tons</c><00:12:30.020><c> of</c><00:12:30.200><c> information</c><00:12:31.040><c> we</c><00:12:31.850><c> decided</c>

00:12:31.960 --> 00:12:31.970 align:start position:0%
assembles tons of information we decided
 

00:12:31.970 --> 00:12:34.420 align:start position:0%
assembles tons of information we decided
to<00:12:32.630><c> instead</c><00:12:33.230><c> replace</c><00:12:33.649><c> it</c><00:12:33.890><c> by</c><00:12:34.010><c> a</c><00:12:34.040><c> component</c>

00:12:34.420 --> 00:12:34.430 align:start position:0%
to instead replace it by a component
 

00:12:34.430 --> 00:12:39.340 align:start position:0%
to instead replace it by a component
that<00:12:34.610><c> performs</c><00:12:36.130><c> many</c><00:12:37.130><c> tiny</c><00:12:38.350><c> local</c>

00:12:39.340 --> 00:12:39.350 align:start position:0%
that performs many tiny local
 

00:12:39.350 --> 00:12:44.440 align:start position:0%
that performs many tiny local
transformations<00:12:40.100><c> to</c><00:12:41.029><c> the</c><00:12:41.060><c> code</c><00:12:41.529><c> so</c><00:12:43.450><c> every</c>

00:12:44.440 --> 00:12:44.450 align:start position:0%
transformations to the code so every
 

00:12:44.450 --> 00:12:46.210 align:start position:0%
transformations to the code so every
single<00:12:44.959><c> step</c><00:12:45.260><c> of</c><00:12:45.440><c> the</c><00:12:45.560><c> component</c><00:12:46.040><c> there's</c>

00:12:46.210 --> 00:12:46.220 align:start position:0%
single step of the component there's
 

00:12:46.220 --> 00:12:48.790 align:start position:0%
single step of the component there's
only<00:12:46.430><c> one</c><00:12:47.089><c> so</c><00:12:47.510><c> every</c><00:12:47.750><c> single</c><00:12:47.899><c> step</c><00:12:48.140><c> of</c><00:12:48.290><c> every</c>

00:12:48.790 --> 00:12:48.800 align:start position:0%
only one so every single step of every
 

00:12:48.800 --> 00:12:51.100 align:start position:0%
only one so every single step of every
single<00:12:49.370><c> component</c><00:12:49.880><c> of</c><00:12:50.270><c> the</c><00:12:50.540><c> optimizer</c>

00:12:51.100 --> 00:12:51.110 align:start position:0%
single component of the optimizer
 

00:12:51.110 --> 00:12:53.439 align:start position:0%
single component of the optimizer
there's<00:12:51.829><c> only</c><00:12:51.980><c> one</c><00:12:52.279><c> single</c><00:12:52.579><c> thing</c><00:12:52.880><c> only</c><00:12:53.120><c> one</c>

00:12:53.439 --> 00:12:53.449 align:start position:0%
there's only one single thing only one
 

00:12:53.449 --> 00:12:57.220 align:start position:0%
there's only one single thing only one
small<00:12:54.020><c> transformation</c><00:12:54.980><c> on</c><00:12:55.160><c> the</c><00:12:55.930><c> yule</c><00:12:56.930><c> code</c>

00:12:57.220 --> 00:12:57.230 align:start position:0%
small transformation on the yule code
 

00:12:57.230 --> 00:12:59.410 align:start position:0%
small transformation on the yule code
and<00:12:57.500><c> the</c><00:12:58.040><c> output</c><00:12:58.459><c> of</c><00:12:58.490><c> each</c><00:12:58.699><c> of</c><00:12:58.880><c> the</c><00:12:59.000><c> steps</c><00:12:59.240><c> is</c>

00:12:59.410 --> 00:12:59.420 align:start position:0%
and the output of each of the steps is
 

00:12:59.420 --> 00:13:05.139 align:start position:0%
and the output of each of the steps is
always<00:12:59.810><c> again</c><00:13:00.529><c> Google</c><00:13:00.860><c> code</c><00:13:01.040><c> so</c><00:13:01.250><c> it</c><00:13:01.370><c> always</c><00:13:04.149><c> it</c>

00:13:05.139 --> 00:13:05.149 align:start position:0%
always again Google code so it always it
 

00:13:05.149 --> 00:13:06.790 align:start position:0%
always again Google code so it always it
is<00:13:05.209><c> always</c><00:13:05.420><c> readable</c><00:13:05.990><c> it</c><00:13:06.110><c> is</c><00:13:06.199><c> still</c><00:13:06.410><c> text</c>

00:13:06.790 --> 00:13:06.800 align:start position:0%
is always readable it is still text
 

00:13:06.800 --> 00:13:09.160 align:start position:0%
is always readable it is still text
there<00:13:07.040><c> are</c><00:13:07.160><c> no</c><00:13:07.339><c> internal</c><00:13:07.910><c> big</c><00:13:08.630><c> internal</c><00:13:08.990><c> data</c>

00:13:09.160 --> 00:13:09.170 align:start position:0%
there are no internal big internal data
 

00:13:09.170 --> 00:13:14.350 align:start position:0%
there are no internal big internal data
structures<00:13:09.649><c> and</c><00:13:12.579><c> at</c><00:13:13.579><c> every</c><00:13:13.850><c> time</c><00:13:14.060><c> you</c><00:13:14.209><c> can</c>

00:13:14.350 --> 00:13:14.360 align:start position:0%
structures and at every time you can
 

00:13:14.360 --> 00:13:15.760 align:start position:0%
structures and at every time you can
look<00:13:14.660><c> at</c><00:13:14.779><c> it</c><00:13:14.899><c> and</c><00:13:15.050><c> see</c><00:13:15.199><c> whether</c><00:13:15.440><c> the</c>

00:13:15.760 --> 00:13:15.770 align:start position:0%
look at it and see whether the
 

00:13:15.770 --> 00:13:16.600 align:start position:0%
look at it and see whether the
transformation<00:13:16.279><c> was</c><00:13:16.399><c> curved</c>

00:13:16.600 --> 00:13:16.610 align:start position:0%
transformation was curved
 

00:13:16.610 --> 00:13:19.569 align:start position:0%
transformation was curved
not<00:13:16.910><c> and</c><00:13:17.529><c> the</c><00:13:18.529><c> optimizer</c><00:13:18.890><c> also</c><00:13:19.190><c> keeps</c><00:13:19.399><c> the</c>

00:13:19.569 --> 00:13:19.579 align:start position:0%
not and the optimizer also keeps the
 

00:13:19.579 --> 00:13:20.710 align:start position:0%
not and the optimizer also keeps the
structure<00:13:19.940><c> of</c><00:13:20.060><c> the</c><00:13:20.180><c> code</c><00:13:20.300><c> so</c><00:13:20.480><c> it</c><00:13:20.570><c> keeps</c>

00:13:20.710 --> 00:13:20.720 align:start position:0%
structure of the code so it keeps
 

00:13:20.720 --> 00:13:23.019 align:start position:0%
structure of the code so it keeps
functions<00:13:21.230><c> and</c><00:13:21.470><c> loops</c><00:13:22.160><c> it</c><00:13:22.700><c> does</c><00:13:22.880><c> not</c>

00:13:23.019 --> 00:13:23.029 align:start position:0%
functions and loops it does not
 

00:13:23.029 --> 00:13:25.660 align:start position:0%
functions and loops it does not
introduce<00:13:23.240><c> go</c><00:13:23.600><c> tools</c><00:13:23.870><c> and</c><00:13:24.110><c> this</c><00:13:24.649><c> helps</c><00:13:24.980><c> us</c><00:13:25.190><c> for</c>

00:13:25.660 --> 00:13:25.670 align:start position:0%
introduce go tools and this helps us for
 

00:13:25.670 --> 00:13:27.069 align:start position:0%
introduce go tools and this helps us for
the<00:13:25.850><c> translation</c><00:13:26.300><c> to</c><00:13:26.360><c> webassembly</c><00:13:26.690><c> because</c>

00:13:27.069 --> 00:13:27.079 align:start position:0%
the translation to webassembly because
 

00:13:27.079 --> 00:13:28.720 align:start position:0%
the translation to webassembly because
whoever<00:13:27.320><c> simply</c><00:13:27.560><c> does</c><00:13:27.709><c> not</c><00:13:27.740><c> have</c><00:13:27.890><c> go</c><00:13:28.339><c> to</c><00:13:28.370><c> us</c><00:13:28.579><c> it</c>

00:13:28.720 --> 00:13:28.730 align:start position:0%
whoever simply does not have go to us it
 

00:13:28.730 --> 00:13:33.840 align:start position:0%
whoever simply does not have go to us it
only<00:13:28.820><c> has</c><00:13:29.170><c> functions</c><00:13:30.170><c> loops</c><00:13:31.040><c> and</c><00:13:31.339><c> conditions</c>

00:13:33.840 --> 00:13:33.850 align:start position:0%
 
 

00:13:33.850 --> 00:13:37.540 align:start position:0%
 
the<00:13:34.850><c> tricky</c><00:13:35.209><c> part</c><00:13:35.510><c> of</c><00:13:36.370><c> building</c><00:13:37.370><c> the</c>

00:13:37.540 --> 00:13:37.550 align:start position:0%
the tricky part of building the
 

00:13:37.550 --> 00:13:40.420 align:start position:0%
the tricky part of building the
optimizer<00:13:37.970><c> is</c><00:13:38.060><c> when</c><00:13:38.570><c> it's</c><00:13:38.810><c> not</c><00:13:39.100><c> designing</c><00:13:40.100><c> the</c>

00:13:40.420 --> 00:13:40.430 align:start position:0%
optimizer is when it's not designing the
 

00:13:40.430 --> 00:13:41.920 align:start position:0%
optimizer is when it's not designing the
components<00:13:40.970><c> but</c><00:13:41.120><c> coming</c><00:13:41.540><c> up</c><00:13:41.630><c> with</c><00:13:41.779><c> a</c><00:13:41.810><c> good</c>

00:13:41.920 --> 00:13:41.930 align:start position:0%
components but coming up with a good
 

00:13:41.930 --> 00:13:44.040 align:start position:0%
components but coming up with a good
strategy<00:13:42.140><c> on</c><00:13:42.500><c> when</c><00:13:42.709><c> to</c><00:13:42.860><c> call</c><00:13:43.040><c> each</c><00:13:43.250><c> component</c>

00:13:44.040 --> 00:13:44.050 align:start position:0%
strategy on when to call each component
 

00:13:44.050 --> 00:13:47.410 align:start position:0%
strategy on when to call each component
but<00:13:45.050><c> the</c><00:13:45.200><c> good</c><00:13:45.380><c> news</c><00:13:45.410><c> here</c><00:13:45.920><c> is</c><00:13:45.950><c> that</c><00:13:46.120><c> even</c><00:13:47.120><c> if</c>

00:13:47.410 --> 00:13:47.420 align:start position:0%
but the good news here is that even if
 

00:13:47.420 --> 00:13:50.290 align:start position:0%
but the good news here is that even if
this<00:13:47.829><c> this</c><00:13:48.829><c> strategy</c><00:13:49.370><c> turns</c><00:13:49.970><c> out</c><00:13:50.149><c> to</c><00:13:50.269><c> be</c>

00:13:50.290 --> 00:13:50.300 align:start position:0%
this this strategy turns out to be
 

00:13:50.300 --> 00:13:52.840 align:start position:0%
this this strategy turns out to be
suboptimal<00:13:50.899><c> it</c><00:13:51.320><c> will</c><00:13:51.620><c> never</c><00:13:52.010><c> result</c><00:13:52.730><c> in</c>

00:13:52.840 --> 00:13:52.850 align:start position:0%
suboptimal it will never result in
 

00:13:52.850 --> 00:13:57.579 align:start position:0%
suboptimal it will never result in
invalid<00:13:53.450><c> code</c><00:13:53.630><c> because</c><00:13:53.990><c> as</c><00:13:54.320><c> long</c><00:13:55.040><c> as</c><00:13:55.100><c> we</c><00:13:56.589><c> check</c>

00:13:57.579 --> 00:13:57.589 align:start position:0%
invalid code because as long as we check
 

00:13:57.589 --> 00:13:59.319 align:start position:0%
invalid code because as long as we check
that<00:13:57.800><c> every</c><00:13:58.100><c> of</c><00:13:58.250><c> these</c><00:13:58.430><c> small</c><00:13:59.029><c> time</c>

00:13:59.319 --> 00:13:59.329 align:start position:0%
that every of these small time
 

00:13:59.329 --> 00:14:02.250 align:start position:0%
that every of these small time
transformations<00:14:00.250><c> does</c><00:14:01.250><c> its</c><00:14:01.430><c> job</c><00:14:01.490><c> correctly</c>

00:14:02.250 --> 00:14:02.260 align:start position:0%
transformations does its job correctly
 

00:14:02.260 --> 00:14:04.960 align:start position:0%
transformations does its job correctly
then<00:14:03.260><c> any</c><00:14:03.740><c> combination</c><00:14:04.310><c> of</c><00:14:04.370><c> these</c><00:14:04.519><c> steps</c><00:14:04.760><c> will</c>

00:14:04.960 --> 00:14:04.970 align:start position:0%
then any combination of these steps will
 

00:14:04.970 --> 00:14:06.670 align:start position:0%
then any combination of these steps will
always<00:14:05.240><c> result</c><00:14:05.600><c> it</c><00:14:05.839><c> will</c><00:14:05.959><c> also</c><00:14:06.230><c> result</c><00:14:06.380><c> in</c>

00:14:06.670 --> 00:14:06.680 align:start position:0%
always result it will also result in
 

00:14:06.680 --> 00:14:08.889 align:start position:0%
always result it will also result in
correct<00:14:07.040><c> code</c><00:14:07.220><c> it</c><00:14:07.459><c> might</c><00:14:07.610><c> be</c><00:14:07.820><c> less</c><00:14:08.510><c> efficient</c>

00:14:08.889 --> 00:14:08.899 align:start position:0%
correct code it might be less efficient
 

00:14:08.899 --> 00:14:11.560 align:start position:0%
correct code it might be less efficient
but<00:14:08.959><c> it</c><00:14:09.110><c> will</c><00:14:09.200><c> always</c><00:14:09.320><c> be</c><00:14:09.440><c> correct</c><00:14:10.420><c> okay</c><00:14:11.420><c> now</c>

00:14:11.560 --> 00:14:11.570 align:start position:0%
but it will always be correct okay now
 

00:14:11.570 --> 00:14:13.630 align:start position:0%
but it will always be correct okay now
let's<00:14:12.140><c> take</c><00:14:12.260><c> an</c><00:14:12.380><c> example</c><00:14:12.440><c> let's</c><00:14:13.339><c> take</c><00:14:13.459><c> a</c><00:14:13.519><c> look</c>

00:14:13.630 --> 00:14:13.640 align:start position:0%
let's take an example let's take a look
 

00:14:13.640 --> 00:14:15.910 align:start position:0%
let's take an example let's take a look
at<00:14:13.730><c> example</c><00:14:14.149><c> this</c><00:14:14.810><c> is</c><00:14:15.140><c> your</c><00:14:15.529><c> code</c><00:14:15.890><c> that</c>

00:14:15.910 --> 00:14:15.920 align:start position:0%
at example this is your code that
 

00:14:15.920 --> 00:14:18.430 align:start position:0%
at example this is your code that
computes<00:14:16.550><c> the</c><00:14:16.970><c> sum</c><00:14:17.149><c> of</c><00:14:17.269><c> an</c><00:14:17.390><c> array</c><00:14:17.630><c> so</c><00:14:18.200><c> we</c><00:14:18.230><c> have</c>

00:14:18.430 --> 00:14:18.440 align:start position:0%
computes the sum of an array so we have
 

00:14:18.440 --> 00:14:21.460 align:start position:0%
computes the sum of an array so we have
the<00:14:18.560><c> first</c><00:14:18.769><c> function</c><00:14:18.950><c> that</c><00:14:19.510><c> has</c><00:14:20.510><c> a</c><00:14:20.540><c> for</c><00:14:21.230><c> loop</c>

00:14:21.460 --> 00:14:21.470 align:start position:0%
the first function that has a for loop
 

00:14:21.470 --> 00:14:24.639 align:start position:0%
the first function that has a for loop
over<00:14:21.680><c> the</c><00:14:21.949><c> array</c><00:14:22.370><c> elements</c><00:14:23.029><c> and</c><00:14:23.360><c> this</c><00:14:24.290><c> first</c>

00:14:24.639 --> 00:14:24.649 align:start position:0%
over the array elements and this first
 

00:14:24.649 --> 00:14:27.400 align:start position:0%
over the array elements and this first
function<00:14:25.130><c> calls</c><00:14:25.940><c> the</c><00:14:26.300><c> second</c><00:14:26.660><c> function</c><00:14:26.870><c> and</c>

00:14:27.400 --> 00:14:27.410 align:start position:0%
function calls the second function and
 

00:14:27.410 --> 00:14:31.060 align:start position:0%
function calls the second function and
the<00:14:28.190><c> second</c><00:14:28.459><c> function</c><00:14:29.380><c> retrieves</c><00:14:30.380><c> a</c><00:14:30.680><c> single</c>

00:14:31.060 --> 00:14:31.070 align:start position:0%
the second function retrieves a single
 

00:14:31.070 --> 00:14:33.040 align:start position:0%
the second function retrieves a single
array<00:14:31.279><c> element</c><00:14:31.670><c> so</c><00:14:31.820><c> access</c><00:14:32.240><c> the</c><00:14:32.360><c> array</c><00:14:32.630><c> and</c><00:14:32.870><c> I</c>

00:14:33.040 --> 00:14:33.050 align:start position:0%
array element so access the array and I
 

00:14:33.050 --> 00:14:36.370 align:start position:0%
array element so access the array and I
is<00:14:33.110><c> the</c><00:14:33.410><c> position</c><00:14:34.130><c> in</c><00:14:34.880><c> the</c><00:14:35.180><c> array</c><00:14:35.380><c> the</c>

00:14:36.370 --> 00:14:36.380 align:start position:0%
is the position in the array the
 

00:14:36.380 --> 00:14:37.810 align:start position:0%
is the position in the array the
interesting<00:14:36.740><c> thing</c><00:14:36.920><c> here</c><00:14:37.100><c> is</c><00:14:37.279><c> that</c><00:14:37.310><c> a</c><00:14:37.550><c> ray</c>

00:14:37.810 --> 00:14:37.820 align:start position:0%
interesting thing here is that a ray
 

00:14:37.820 --> 00:14:42.460 align:start position:0%
interesting thing here is that a ray
load<00:14:38.060><c> performs</c><00:14:38.540><c> bounds</c><00:14:38.899><c> checking</c><00:14:39.260><c> so</c><00:14:41.470><c> array</c>

00:14:42.460 --> 00:14:42.470 align:start position:0%
load performs bounds checking so array
 

00:14:42.470 --> 00:14:46.120 align:start position:0%
load performs bounds checking so array
load<00:14:43.449><c> checks</c><00:14:44.449><c> whether</c><00:14:44.720><c> I</c><00:14:44.810><c> is</c><00:14:45.019><c> less</c><00:14:45.560><c> than</c><00:14:45.620><c> the</c>

00:14:46.120 --> 00:14:46.130 align:start position:0%
load checks whether I is less than the
 

00:14:46.130 --> 00:14:50.980 align:start position:0%
load checks whether I is less than the
length<00:14:46.310><c> of</c><00:14:46.519><c> the</c><00:14:46.699><c> array</c><00:14:46.940><c> and</c><00:14:48.610><c> this</c><00:14:49.610><c> in</c><00:14:50.120><c> the</c><00:14:50.750><c> form</c>

00:14:50.980 --> 00:14:50.990 align:start position:0%
length of the array and this in the form
 

00:14:50.990 --> 00:14:52.389 align:start position:0%
length of the array and this in the form
here<00:14:51.230><c> it's</c><00:14:51.410><c> inefficient</c><00:14:51.709><c> because</c><00:14:51.980><c> it's</c><00:14:52.279><c> done</c>

00:14:52.389 --> 00:14:52.399 align:start position:0%
here it's inefficient because it's done
 

00:14:52.399 --> 00:14:55.720 align:start position:0%
here it's inefficient because it's done
in<00:14:52.519><c> every</c><00:14:52.640><c> single</c><00:14:53.149><c> loop</c><00:14:53.480><c> iteration</c><00:14:53.990><c> but</c><00:14:54.589><c> it</c><00:14:55.550><c> is</c>

00:14:55.720 --> 00:14:55.730 align:start position:0%
in every single loop iteration but it is
 

00:14:55.730 --> 00:14:58.389 align:start position:0%
in every single loop iteration but it is
very<00:14:56.329><c> safe</c><00:14:56.540><c> because</c><00:14:56.810><c> we</c><00:14:57.260><c> do</c><00:14:57.740><c> it</c><00:14:57.920><c> every</c><00:14:58.100><c> single</c>

00:14:58.389 --> 00:14:58.399 align:start position:0%
very safe because we do it every single
 

00:14:58.399 --> 00:15:00.519 align:start position:0%
very safe because we do it every single
loop<00:14:58.579><c> iteration</c><00:14:59.029><c> and</c><00:14:59.209><c> the</c><00:14:59.839><c> cool</c><00:14:59.990><c> thing</c><00:15:00.199><c> now</c><00:15:00.230><c> is</c>

00:15:00.519 --> 00:15:00.529 align:start position:0%
loop iteration and the cool thing now is
 

00:15:00.529 --> 00:15:02.199 align:start position:0%
loop iteration and the cool thing now is
that<00:15:00.560><c> we</c><00:15:00.740><c> will</c><00:15:00.980><c> see</c><00:15:01.130><c> that</c><00:15:01.339><c> the</c><00:15:01.699><c> optimizer</c><00:15:02.060><c> is</c>

00:15:02.199 --> 00:15:02.209 align:start position:0%
that we will see that the optimizer is
 

00:15:02.209 --> 00:15:05.829 align:start position:0%
that we will see that the optimizer is
able<00:15:02.540><c> to</c><00:15:03.100><c> remove</c><00:15:04.100><c> these</c><00:15:04.850><c> bounds</c><00:15:05.300><c> checks</c><00:15:05.540><c> with</c>

00:15:05.829 --> 00:15:05.839 align:start position:0%
able to remove these bounds checks with
 

00:15:05.839 --> 00:15:08.530 align:start position:0%
able to remove these bounds checks with
equivalent<00:15:06.339><c> transformations</c><00:15:07.339><c> so</c><00:15:08.180><c> the</c><00:15:08.329><c> first</c>

00:15:08.530 --> 00:15:08.540 align:start position:0%
equivalent transformations so the first
 

00:15:08.540 --> 00:15:10.780 align:start position:0%
equivalent transformations so the first
thing<00:15:08.750><c> that</c><00:15:09.199><c> happens</c><00:15:09.560><c> is</c><00:15:09.709><c> that</c><00:15:09.890><c> we</c><00:15:09.949><c> explode</c>

00:15:10.780 --> 00:15:10.790 align:start position:0%
thing that happens is that we explode
 

00:15:10.790 --> 00:15:13.720 align:start position:0%
thing that happens is that we explode
this<00:15:11.149><c> large</c><00:15:11.990><c> expression</c><00:15:12.920><c> into</c><00:15:13.430><c> an</c>

00:15:13.720 --> 00:15:13.730 align:start position:0%
this large expression into an
 

00:15:13.730 --> 00:15:17.230 align:start position:0%
this large expression into an
intermediate<00:15:14.589><c> assignment</c><00:15:15.589><c> and</c><00:15:15.910><c> now</c><00:15:16.910><c> we</c><00:15:16.970><c> have</c>

00:15:17.230 --> 00:15:17.240 align:start position:0%
intermediate assignment and now we have
 

00:15:17.240 --> 00:15:20.680 align:start position:0%
intermediate assignment and now we have
the<00:15:17.720><c> the</c><00:15:18.110><c> function</c><00:15:18.290><c> call</c><00:15:18.620><c> isolated</c><00:15:19.279><c> and</c><00:15:19.690><c> since</c>

00:15:20.680 --> 00:15:20.690 align:start position:0%
the the function call isolated and since
 

00:15:20.690 --> 00:15:21.970 align:start position:0%
the the function call isolated and since
it's<00:15:20.839><c> only</c><00:15:20.930><c> called</c><00:15:21.320><c> the</c><00:15:21.529><c> since</c><00:15:21.709><c> the</c><00:15:21.829><c> function</c>

00:15:21.970 --> 00:15:21.980 align:start position:0%
it's only called the since the function
 

00:15:21.980 --> 00:15:24.370 align:start position:0%
it's only called the since the function
is<00:15:22.190><c> only</c><00:15:22.279><c> called</c><00:15:22.579><c> once</c><00:15:22.790><c> we</c><00:15:23.570><c> can</c><00:15:23.720><c> inline</c><00:15:23.990><c> it</c><00:15:24.140><c> so</c>

00:15:24.370 --> 00:15:24.380 align:start position:0%
is only called once we can inline it so
 

00:15:24.380 --> 00:15:26.319 align:start position:0%
is only called once we can inline it so
we<00:15:24.560><c> can</c><00:15:24.740><c> replace</c><00:15:24.980><c> the</c><00:15:25.220><c> function</c><00:15:25.550><c> call</c><00:15:25.760><c> by</c><00:15:26.300><c> the</c>

00:15:26.319 --> 00:15:26.329 align:start position:0%
we can replace the function call by the
 

00:15:26.329 --> 00:15:29.079 align:start position:0%
we can replace the function call by the
body<00:15:26.660><c> of</c><00:15:26.839><c> the</c><00:15:26.959><c> function</c><00:15:27.140><c> so</c><00:15:27.380><c> that's</c><00:15:28.060><c> any</c><00:15:29.060><c> more</c>

00:15:29.079 --> 00:15:29.089 align:start position:0%
body of the function so that's any more
 

00:15:29.089 --> 00:15:30.470 align:start position:0%
body of the function so that's any more
drastic<00:15:29.660><c> change</c><00:15:29.959><c> to</c><00:15:30.199><c> the</c>

00:15:30.470 --> 00:15:30.480 align:start position:0%
drastic change to the
 

00:15:30.480 --> 00:15:35.180 align:start position:0%
drastic change to the
but<00:15:31.079><c> it's</c><00:15:31.440><c> simple</c><00:15:31.769><c> enough</c><00:15:31.860><c> and</c><00:15:33.680><c> now</c><00:15:34.680><c> the</c><00:15:34.740><c> next</c>

00:15:35.180 --> 00:15:35.190 align:start position:0%
but it's simple enough and now the next
 

00:15:35.190 --> 00:15:36.560 align:start position:0%
but it's simple enough and now the next
thing<00:15:35.430><c> that</c><00:15:35.490><c> happens</c><00:15:35.880><c> is</c><00:15:35.970><c> we</c><00:15:36.120><c> remove</c><00:15:36.389><c> this</c>

00:15:36.560 --> 00:15:36.570 align:start position:0%
thing that happens is we remove this
 

00:15:36.570 --> 00:15:40.639 align:start position:0%
thing that happens is we remove this
useless<00:15:37.339><c> additional</c><00:15:38.339><c> indented</c><00:15:39.209><c> block</c><00:15:39.389><c> and</c><00:15:39.810><c> we</c>

00:15:40.639 --> 00:15:40.649 align:start position:0%
useless additional indented block and we
 

00:15:40.649 --> 00:15:44.420 align:start position:0%
useless additional indented block and we
also<00:15:40.920><c> rename</c><00:15:41.339><c> one</c><00:15:41.820><c> of</c><00:15:42.060><c> the</c><00:15:42.180><c> variables</c><00:15:43.430><c> okay</c>

00:15:44.420 --> 00:15:44.430 align:start position:0%
also rename one of the variables okay
 

00:15:44.430 --> 00:15:46.250 align:start position:0%
also rename one of the variables okay
now<00:15:44.579><c> it's</c><00:15:44.760><c> already</c><00:15:45.660><c> a</c><00:15:45.750><c> little</c><00:15:45.930><c> bit</c><00:15:46.019><c> clearer</c>

00:15:46.250 --> 00:15:46.260 align:start position:0%
now it's already a little bit clearer
 

00:15:46.260 --> 00:15:48.639 align:start position:0%
now it's already a little bit clearer
now<00:15:47.070><c> we</c><00:15:47.130><c> change</c><00:15:47.519><c> the</c><00:15:47.579><c> formatting</c><00:15:47.940><c> a</c><00:15:48.089><c> little</c>

00:15:48.639 --> 00:15:48.649 align:start position:0%
now we change the formatting a little
 

00:15:48.649 --> 00:15:53.420 align:start position:0%
now we change the formatting a little
okay<00:15:49.649><c> so</c><00:15:50.600><c> this</c><00:15:51.600><c> was</c><00:15:51.810><c> already</c><00:15:52.100><c> one</c><00:15:53.100><c> of</c><00:15:53.190><c> the</c><00:15:53.310><c> two</c>

00:15:53.420 --> 00:15:53.430 align:start position:0%
okay so this was already one of the two
 

00:15:53.430 --> 00:15:56.689 align:start position:0%
okay so this was already one of the two
tricky<00:15:53.699><c> parts</c><00:15:54.000><c> now</c><00:15:54.870><c> what</c><00:15:55.440><c> happens</c><00:15:55.769><c> next</c><00:15:56.399><c> is</c>

00:15:56.689 --> 00:15:56.699 align:start position:0%
tricky parts now what happens next is
 

00:15:56.699 --> 00:15:59.240 align:start position:0%
tricky parts now what happens next is
that<00:15:56.810><c> we</c><00:15:57.810><c> take</c><00:15:57.990><c> a</c><00:15:58.019><c> look</c><00:15:58.260><c> at</c><00:15:58.500><c> all</c><00:15:58.889><c> the</c>

00:15:59.240 --> 00:15:59.250 align:start position:0%
that we take a look at all the
 

00:15:59.250 --> 00:16:01.579 align:start position:0%
that we take a look at all the
statements<00:15:59.790><c> inside</c><00:16:00.420><c> the</c><00:16:00.480><c> loop</c><00:16:00.810><c> buddy</c><00:16:01.050><c> and</c><00:16:01.320><c> see</c>

00:16:01.579 --> 00:16:01.589 align:start position:0%
statements inside the loop buddy and see
 

00:16:01.589 --> 00:16:04.129 align:start position:0%
statements inside the loop buddy and see
if<00:16:01.880><c> some</c><00:16:02.880><c> of</c><00:16:02.970><c> the</c><00:16:03.060><c> statements</c><00:16:03.510><c> don't</c><00:16:03.720><c> actually</c>

00:16:04.129 --> 00:16:04.139 align:start position:0%
if some of the statements don't actually
 

00:16:04.139 --> 00:16:08.540 align:start position:0%
if some of the statements don't actually
depend<00:16:04.470><c> on</c><00:16:04.740><c> the</c><00:16:05.010><c> iteration</c><00:16:05.519><c> at</c><00:16:05.610><c> all</c><00:16:05.760><c> so</c><00:16:07.550><c> the</c>

00:16:08.540 --> 00:16:08.550 align:start position:0%
depend on the iteration at all so the
 

00:16:08.550 --> 00:16:10.340 align:start position:0%
depend on the iteration at all so the
only<00:16:08.699><c> variable</c><00:16:09.240><c> that</c><00:16:09.269><c> is</c><00:16:09.480><c> reassigned</c><00:16:09.930><c> inside</c>

00:16:10.340 --> 00:16:10.350 align:start position:0%
only variable that is reassigned inside
 

00:16:10.350 --> 00:16:14.180 align:start position:0%
only variable that is reassigned inside
the<00:16:10.500><c> loop</c><00:16:10.649><c> is</c><00:16:10.889><c> some</c><00:16:11.550><c> and</c><00:16:11.850><c> I</c><00:16:12.170><c> so</c><00:16:13.190><c> everything</c>

00:16:14.180 --> 00:16:14.190 align:start position:0%
the loop is some and I so everything
 

00:16:14.190 --> 00:16:16.340 align:start position:0%
the loop is some and I so everything
that<00:16:14.220><c> is</c><00:16:14.370><c> not</c><00:16:14.579><c> depend</c><00:16:15.000><c> on</c><00:16:15.149><c> some</c><00:16:15.449><c> or</c><00:16:15.690><c> I</c><00:16:15.750><c> or</c>

00:16:16.340 --> 00:16:16.350 align:start position:0%
that is not depend on some or I or
 

00:16:16.350 --> 00:16:18.079 align:start position:0%
that is not depend on some or I or
anything<00:16:16.589><c> that</c><00:16:16.740><c> depends</c><00:16:17.160><c> on</c><00:16:17.250><c> somewhere</c><00:16:17.490><c> I</c><00:16:17.550><c> can</c>

00:16:18.079 --> 00:16:18.089 align:start position:0%
anything that depends on somewhere I can
 

00:16:18.089 --> 00:16:20.030 align:start position:0%
anything that depends on somewhere I can
be<00:16:18.240><c> pulled</c><00:16:18.510><c> out</c><00:16:18.720><c> of</c><00:16:18.750><c> the</c><00:16:19.019><c> loop</c><00:16:19.170><c> and</c><00:16:19.320><c> that's</c><00:16:19.740><c> not</c>

00:16:20.030 --> 00:16:20.040 align:start position:0%
be pulled out of the loop and that's not
 

00:16:20.040 --> 00:16:22.160 align:start position:0%
be pulled out of the loop and that's not
executed<00:16:20.880><c> for</c><00:16:21.029><c> every</c><00:16:21.240><c> single</c><00:16:21.600><c> loop</c><00:16:21.720><c> iteration</c>

00:16:22.160 --> 00:16:22.170 align:start position:0%
executed for every single loop iteration
 

00:16:22.170 --> 00:16:25.329 align:start position:0%
executed for every single loop iteration
but<00:16:22.290><c> only</c><00:16:22.470><c> once</c><00:16:23.089><c> before</c><00:16:24.089><c> the</c><00:16:24.389><c> loop</c><00:16:24.420><c> starts</c>

00:16:25.329 --> 00:16:25.339 align:start position:0%
but only once before the loop starts
 

00:16:25.339 --> 00:16:29.050 align:start position:0%
but only once before the loop starts
okay<00:16:26.339><c> so</c><00:16:27.089><c> there</c><00:16:27.240><c> was</c><00:16:27.360><c> data</c><00:16:27.600><c> and</c><00:16:27.810><c> Len</c><00:16:27.990><c> now</c><00:16:28.860><c> we</c>

00:16:29.050 --> 00:16:29.060 align:start position:0%
okay so there was data and Len now we
 

00:16:29.060 --> 00:16:31.879 align:start position:0%
okay so there was data and Len now we
realized<00:16:30.060><c> that</c><00:16:30.360><c> length</c><00:16:30.899><c> and</c><00:16:31.230><c> length</c><00:16:31.440><c> they</c><00:16:31.860><c> are</c>

00:16:31.879 --> 00:16:31.889 align:start position:0%
realized that length and length they are
 

00:16:31.889 --> 00:16:35.600 align:start position:0%
realized that length and length they are
assigned<00:16:32.519><c> the</c><00:16:32.790><c> same</c><00:16:33.000><c> value</c><00:16:33.860><c> sits</c><00:16:34.860><c> since</c><00:16:35.279><c> it's</c>

00:16:35.600 --> 00:16:35.610 align:start position:0%
assigned the same value sits since it's
 

00:16:35.610 --> 00:16:40.579 align:start position:0%
assigned the same value sits since it's
a<00:16:35.790><c> memory</c><00:16:36.149><c> load</c><00:16:36.860><c> it's</c><00:16:38.209><c> it</c><00:16:39.209><c> might</c><00:16:39.600><c> not</c><00:16:39.990><c> be</c><00:16:40.320><c> the</c>

00:16:40.579 --> 00:16:40.589 align:start position:0%
a memory load it's it might not be the
 

00:16:40.589 --> 00:16:43.370 align:start position:0%
a memory load it's it might not be the
same<00:16:40.769><c> value</c><00:16:41.010><c> in</c><00:16:41.279><c> the</c><00:16:41.399><c> end</c><00:16:41.959><c> but</c><00:16:42.959><c> if</c><00:16:43.079><c> the</c><00:16:43.230><c> memory</c>

00:16:43.370 --> 00:16:43.380 align:start position:0%
same value in the end but if the memory
 

00:16:43.380 --> 00:16:45.230 align:start position:0%
same value in the end but if the memory
does<00:16:43.680><c> not</c><00:16:43.860><c> change</c><00:16:44.100><c> between</c><00:16:44.459><c> these</c><00:16:44.760><c> two</c><00:16:44.940><c> memory</c>

00:16:45.230 --> 00:16:45.240 align:start position:0%
does not change between these two memory
 

00:16:45.240 --> 00:16:47.509 align:start position:0%
does not change between these two memory
load<00:16:45.420><c> operations</c><00:16:45.990><c> then</c><00:16:46.260><c> of</c><00:16:46.890><c> course</c><00:16:47.160><c> it</c><00:16:47.220><c> has</c><00:16:47.279><c> to</c>

00:16:47.509 --> 00:16:47.519 align:start position:0%
load operations then of course it has to
 

00:16:47.519 --> 00:16:49.009 align:start position:0%
load operations then of course it has to
be<00:16:47.579><c> the</c><00:16:47.699><c> same</c><00:16:47.880><c> value</c><00:16:48.180><c> and</c><00:16:48.360><c> this</c><00:16:48.570><c> is</c><00:16:48.630><c> the</c><00:16:48.839><c> case</c>

00:16:49.009 --> 00:16:49.019 align:start position:0%
be the same value and this is the case
 

00:16:49.019 --> 00:16:54.259 align:start position:0%
be the same value and this is the case
here<00:16:49.290><c> so</c><00:16:49.350><c> we</c><00:16:49.709><c> do</c><00:16:49.829><c> not</c><00:16:49.980><c> modify</c><00:16:50.250><c> memory</c><00:16:53.029><c> so</c><00:16:54.029><c> Len</c>

00:16:54.259 --> 00:16:54.269 align:start position:0%
here so we do not modify memory so Len
 

00:16:54.269 --> 00:16:55.759 align:start position:0%
here so we do not modify memory so Len
and<00:16:54.480><c> length</c><00:16:54.660><c> are</c><00:16:54.899><c> actually</c><00:16:55.260><c> the</c><00:16:55.350><c> same</c><00:16:55.380><c> thing</c>

00:16:55.759 --> 00:16:55.769 align:start position:0%
and length are actually the same thing
 

00:16:55.769 --> 00:16:59.090 align:start position:0%
and length are actually the same thing
which<00:16:56.519><c> means</c><00:16:56.760><c> we</c><00:16:57.120><c> can</c><00:16:57.380><c> remove</c><00:16:58.380><c> Len</c><00:16:58.709><c> and</c>

00:16:59.090 --> 00:16:59.100 align:start position:0%
which means we can remove Len and
 

00:16:59.100 --> 00:17:04.730 align:start position:0%
which means we can remove Len and
replace<00:16:59.579><c> every</c><00:17:00.089><c> Len</c><00:17:00.300><c> by</c><00:17:00.690><c> length</c><00:17:01.940><c> okay</c><00:17:02.940><c> and</c><00:17:03.740><c> now</c>

00:17:04.730 --> 00:17:04.740 align:start position:0%
replace every Len by length okay and now
 

00:17:04.740 --> 00:17:07.220 align:start position:0%
replace every Len by length okay and now
we<00:17:04.799><c> see</c><00:17:05.189><c> that</c><00:17:05.540><c> inside</c><00:17:06.540><c> this</c><00:17:06.660><c> if</c><00:17:06.870><c> statement</c>

00:17:07.220 --> 00:17:07.230 align:start position:0%
we see that inside this if statement
 

00:17:07.230 --> 00:17:09.679 align:start position:0%
we see that inside this if statement
inside<00:17:07.709><c> the</c><00:17:08.040><c> loop</c><00:17:08.220><c> yeah</c><00:17:09.089><c> that's</c><00:17:09.299><c> that</c><00:17:09.390><c> the</c>

00:17:09.679 --> 00:17:09.689 align:start position:0%
inside the loop yeah that's that the
 

00:17:09.689 --> 00:17:11.539 align:start position:0%
inside the loop yeah that's that the
point<00:17:10.020><c> where</c><00:17:10.199><c> I</c><00:17:10.230><c> could</c><00:17:10.949><c> use</c><00:17:10.980><c> a</c><00:17:11.130><c> laser</c><00:17:11.309><c> pointer</c>

00:17:11.539 --> 00:17:11.549 align:start position:0%
point where I could use a laser pointer
 

00:17:11.549 --> 00:17:14.750 align:start position:0%
point where I could use a laser pointer
but<00:17:11.880><c> so</c><00:17:12.870><c> there</c><00:17:13.049><c> is</c><00:17:13.140><c> a</c><00:17:13.169><c> less</c><00:17:13.530><c> than</c><00:17:13.559><c> eye</c><00:17:14.130><c> length</c>

00:17:14.750 --> 00:17:14.760 align:start position:0%
but so there is a less than eye length
 

00:17:14.760 --> 00:17:17.840 align:start position:0%
but so there is a less than eye length
so<00:17:15.150><c> if</c><00:17:15.360><c> is</c><00:17:15.540><c> 0</c><00:17:15.839><c> less</c><00:17:16.439><c> than</c><00:17:16.470><c> I</c><00:17:16.919><c> length</c><00:17:17.250><c> revert</c>

00:17:17.840 --> 00:17:17.850 align:start position:0%
so if is 0 less than I length revert
 

00:17:17.850 --> 00:17:19.970 align:start position:0%
so if is 0 less than I length revert
that<00:17:18.059><c> is</c><00:17:18.449><c> the</c><00:17:18.540><c> bounce</c><00:17:18.750><c> check</c><00:17:19.020><c> we</c><00:17:19.199><c> had</c><00:17:19.380><c> in</c><00:17:19.650><c> the</c>

00:17:19.970 --> 00:17:19.980 align:start position:0%
that is the bounce check we had in the
 

00:17:19.980 --> 00:17:26.299 align:start position:0%
that is the bounce check we had in the
in<00:17:20.669><c> the</c><00:17:20.939><c> function</c><00:17:21.870><c> and</c><00:17:23.750><c> we</c><00:17:24.750><c> realize</c><00:17:25.169><c> that</c><00:17:25.309><c> less</c>

00:17:26.299 --> 00:17:26.309 align:start position:0%
in the function and we realize that less
 

00:17:26.309 --> 00:17:27.799 align:start position:0%
in the function and we realize that less
than<00:17:26.370><c> eye</c><00:17:26.850><c> length</c><00:17:27.150><c> is</c><00:17:27.329><c> also</c><00:17:27.569><c> the</c><00:17:27.660><c> loop</c>

00:17:27.799 --> 00:17:27.809 align:start position:0%
than eye length is also the loop
 

00:17:27.809 --> 00:17:29.630 align:start position:0%
than eye length is also the loop
condition<00:17:28.020><c> so</c><00:17:28.380><c> the</c><00:17:28.500><c> for</c><00:17:28.740><c> loop</c><00:17:28.919><c> has</c><00:17:29.580><c> a</c>

00:17:29.630 --> 00:17:29.640 align:start position:0%
condition so the for loop has a
 

00:17:29.640 --> 00:17:32.299 align:start position:0%
condition so the for loop has a
condition<00:17:30.179><c> and</c><00:17:30.510><c> it</c><00:17:31.320><c> runs</c><00:17:31.470><c> as</c><00:17:31.679><c> long</c><00:17:31.860><c> as</c><00:17:32.010><c> this</c><00:17:32.160><c> is</c>

00:17:32.299 --> 00:17:32.309 align:start position:0%
condition and it runs as long as this is
 

00:17:32.309 --> 00:17:34.220 align:start position:0%
condition and it runs as long as this is
true<00:17:32.490><c> so</c><00:17:32.790><c> as</c><00:17:33.030><c> long</c><00:17:33.179><c> as</c><00:17:33.299><c> I</c><00:17:33.419><c> is</c><00:17:33.450><c> Len</c><00:17:33.750><c> less</c><00:17:34.020><c> than</c>

00:17:34.220 --> 00:17:34.230 align:start position:0%
true so as long as I is Len less than
 

00:17:34.230 --> 00:17:36.710 align:start position:0%
true so as long as I is Len less than
length<00:17:34.410><c> the</c><00:17:35.250><c> for</c><00:17:35.460><c> loop</c><00:17:35.580><c> runs</c><00:17:35.790><c> and</c><00:17:36.059><c> this</c><00:17:36.450><c> means</c>

00:17:36.710 --> 00:17:36.720 align:start position:0%
length the for loop runs and this means
 

00:17:36.720 --> 00:17:38.539 align:start position:0%
length the for loop runs and this means
that<00:17:36.870><c> inside</c><00:17:37.320><c> the</c><00:17:37.470><c> loop</c><00:17:37.620><c> inside</c><00:17:38.190><c> the</c><00:17:38.280><c> body</c><00:17:38.460><c> of</c>

00:17:38.539 --> 00:17:38.549 align:start position:0%
that inside the loop inside the body of
 

00:17:38.549 --> 00:17:41.240 align:start position:0%
that inside the loop inside the body of
the<00:17:38.730><c> for</c><00:17:38.909><c> loop</c><00:17:39.110><c> less</c><00:17:40.110><c> than</c><00:17:40.350><c> I</c><00:17:40.530><c> length</c><00:17:40.860><c> would</c>

00:17:41.240 --> 00:17:41.250 align:start position:0%
the for loop less than I length would
 

00:17:41.250 --> 00:17:42.740 align:start position:0%
the for loop less than I length would
always<00:17:41.429><c> be</c><00:17:41.669><c> true</c><00:17:41.850><c> otherwise</c><00:17:42.210><c> the</c><00:17:42.419><c> body</c><00:17:42.570><c> would</c>

00:17:42.740 --> 00:17:42.750 align:start position:0%
always be true otherwise the body would
 

00:17:42.750 --> 00:17:43.950 align:start position:0%
always be true otherwise the body would
not<00:17:42.840><c> execute</c>

00:17:43.950 --> 00:17:43.960 align:start position:0%
not execute
 

00:17:43.960 --> 00:17:47.009 align:start position:0%
not execute
so<00:17:44.740><c> this</c><00:17:45.460><c> means</c><00:17:45.639><c> inside</c><00:17:45.970><c> this</c><00:17:46.210><c> bounced</c><00:17:46.629><c> check</c>

00:17:47.009 --> 00:17:47.019 align:start position:0%
so this means inside this bounced check
 

00:17:47.019 --> 00:17:49.649 align:start position:0%
so this means inside this bounced check
we<00:17:47.320><c> can</c><00:17:47.499><c> replace</c><00:17:47.799><c> less</c><00:17:48.610><c> than</c><00:17:48.820><c> eye</c><00:17:48.999><c> length</c><00:17:49.269><c> by</c>

00:17:49.649 --> 00:17:49.659 align:start position:0%
we can replace less than eye length by
 

00:17:49.659 --> 00:17:56.940 align:start position:0%
we can replace less than eye length by
true<00:17:50.169><c> or</c><00:17:50.499><c> 1</c><00:17:54.929><c> okay</c><00:17:55.929><c> and</c><00:17:56.049><c> now</c><00:17:56.139><c> we</c><00:17:56.200><c> see</c><00:17:56.440><c> we</c><00:17:56.769><c> have</c><00:17:56.799><c> a</c>

00:17:56.940 --> 00:17:56.950 align:start position:0%
true or 1 okay and now we see we have a
 

00:17:56.950 --> 00:17:59.430 align:start position:0%
true or 1 okay and now we see we have a
constant<00:17:57.549><c> there</c><00:17:57.789><c> and</c><00:17:58.090><c> apply</c><00:17:58.749><c> an</c><00:17:58.809><c> operation</c><00:17:59.320><c> on</c>

00:17:59.430 --> 00:17:59.440 align:start position:0%
constant there and apply an operation on
 

00:17:59.440 --> 00:18:02.700 align:start position:0%
constant there and apply an operation on
that<00:17:59.470><c> is</c><00:17:59.769><c> zero</c><00:18:00.129><c> is</c><00:18:00.369><c> zero</c><00:18:00.669><c> is</c><00:18:00.850><c> the</c><00:18:01.029><c> is</c><00:18:01.869><c> EVM</c><00:18:02.379><c> speak</c>

00:18:02.700 --> 00:18:02.710 align:start position:0%
that is zero is zero is the is EVM speak
 

00:18:02.710 --> 00:18:07.169 align:start position:0%
that is zero is zero is the is EVM speak
for<00:18:03.840><c> logical</c><00:18:04.840><c> negation</c><00:18:05.110><c> so</c><00:18:05.830><c> is</c><00:18:06.159><c> zero</c><00:18:06.610><c> of</c><00:18:06.730><c> one</c>

00:18:07.169 --> 00:18:07.179 align:start position:0%
for logical negation so is zero of one
 

00:18:07.179 --> 00:18:09.840 align:start position:0%
for logical negation so is zero of one
so<00:18:07.720><c> it's</c><00:18:07.929><c> zero</c><00:18:08.230><c> it's</c><00:18:08.619><c> basically</c><00:18:08.889><c> not</c><00:18:09.129><c> true</c>

00:18:09.840 --> 00:18:09.850 align:start position:0%
so it's zero it's basically not true
 

00:18:09.850 --> 00:18:12.600 align:start position:0%
so it's zero it's basically not true
which<00:18:10.269><c> is</c><00:18:10.419><c> false</c><00:18:10.840><c> which</c><00:18:11.139><c> is</c><00:18:11.289><c> zero</c><00:18:11.710><c> so</c><00:18:12.399><c> we</c><00:18:12.429><c> can</c>

00:18:12.600 --> 00:18:12.610 align:start position:0%
which is false which is zero so we can
 

00:18:12.610 --> 00:18:15.919 align:start position:0%
which is false which is zero so we can
replace<00:18:12.759><c> if</c><00:18:13.119><c> it's</c><00:18:13.419><c> zero</c><00:18:13.690><c> of</c><00:18:13.899><c> 1</c><00:18:14.110><c> by</c><00:18:14.320><c> if</c><00:18:14.529><c> zero</c><00:18:15.039><c> and</c>

00:18:15.919 --> 00:18:15.929 align:start position:0%
replace if it's zero of 1 by if zero and
 

00:18:15.929 --> 00:18:18.269 align:start position:0%
replace if it's zero of 1 by if zero and
now<00:18:16.929><c> we</c><00:18:16.960><c> see</c><00:18:17.259><c> so</c><00:18:17.440><c> you</c><00:18:17.499><c> see</c><00:18:17.710><c> these</c><00:18:17.830><c> are</c><00:18:18.009><c> really</c>

00:18:18.269 --> 00:18:18.279 align:start position:0%
now we see so you see these are really
 

00:18:18.279 --> 00:18:21.149 align:start position:0%
now we see so you see these are really
tiny<00:18:18.869><c> modifications</c><00:18:19.869><c> we</c><00:18:20.529><c> could</c><00:18:20.830><c> have</c><00:18:20.919><c> removed</c>

00:18:21.149 --> 00:18:21.159 align:start position:0%
tiny modifications we could have removed
 

00:18:21.159 --> 00:18:23.039 align:start position:0%
tiny modifications we could have removed
the<00:18:21.340><c> if</c><00:18:21.460><c> altogether</c><00:18:21.909><c> or</c><00:18:22.240><c> for</c><00:18:22.690><c> a</c><00:18:22.720><c> long</c><00:18:22.869><c> time</c>

00:18:23.039 --> 00:18:23.049 align:start position:0%
the if altogether or for a long time
 

00:18:23.049 --> 00:18:26.039 align:start position:0%
the if altogether or for a long time
already<00:18:23.200><c> but</c><00:18:23.559><c> we</c><00:18:24.490><c> want</c><00:18:24.639><c> to</c><00:18:24.730><c> keep</c><00:18:24.850><c> every</c><00:18:25.179><c> step</c>

00:18:26.039 --> 00:18:26.049 align:start position:0%
already but we want to keep every step
 

00:18:26.049 --> 00:18:28.889 align:start position:0%
already but we want to keep every step
as<00:18:26.980><c> small</c><00:18:27.309><c> as</c><00:18:27.429><c> possible</c><00:18:27.580><c> so</c><00:18:27.999><c> we</c><00:18:28.360><c> see</c><00:18:28.480><c> if</c><00:18:28.629><c> zero</c>

00:18:28.889 --> 00:18:28.899 align:start position:0%
as small as possible so we see if zero
 

00:18:28.899 --> 00:18:31.230 align:start position:0%
as small as possible so we see if zero
and<00:18:29.289><c> of</c><00:18:29.559><c> course</c><00:18:29.799><c> yeah</c><00:18:30.369><c> it's</c><00:18:30.700><c> a</c><00:18:30.820><c> condition</c><00:18:31.210><c> that</c>

00:18:31.230 --> 00:18:31.240 align:start position:0%
and of course yeah it's a condition that
 

00:18:31.240 --> 00:18:32.730 align:start position:0%
and of course yeah it's a condition that
is<00:18:31.360><c> always</c><00:18:31.659><c> false</c><00:18:31.899><c> so</c><00:18:32.200><c> the</c><00:18:32.379><c> whole</c><00:18:32.529><c> if</c>

00:18:32.730 --> 00:18:32.740 align:start position:0%
is always false so the whole if
 

00:18:32.740 --> 00:18:35.879 align:start position:0%
is always false so the whole if
statement<00:18:33.399><c> can</c><00:18:33.519><c> be</c><00:18:33.549><c> removed</c><00:18:34.289><c> cool</c><00:18:35.289><c> that</c><00:18:35.559><c> so</c>

00:18:35.879 --> 00:18:35.889 align:start position:0%
statement can be removed cool that so
 

00:18:35.889 --> 00:18:37.889 align:start position:0%
statement can be removed cool that so
and<00:18:36.129><c> that</c><00:18:36.369><c> was</c><00:18:36.580><c> did</c><00:18:37.509><c> you</c><00:18:37.570><c> see</c><00:18:37.690><c> the</c><00:18:37.779><c> magic</c>

00:18:37.889 --> 00:18:37.899 align:start position:0%
and that was did you see the magic
 

00:18:37.899 --> 00:18:39.180 align:start position:0%
and that was did you see the magic
happening<00:18:38.320><c> this</c><00:18:38.619><c> is</c><00:18:38.769><c> where</c><00:18:38.919><c> the</c><00:18:39.009><c> balance</c>

00:18:39.180 --> 00:18:39.190 align:start position:0%
happening this is where the balance
 

00:18:39.190 --> 00:18:44.009 align:start position:0%
happening this is where the balance
check<00:18:39.899><c> was</c><00:18:40.899><c> removed</c><00:18:41.259><c> and</c><00:18:41.759><c> now</c><00:18:42.759><c> we</c><00:18:42.820><c> can</c><00:18:43.149><c> do</c><00:18:43.419><c> some</c>

00:18:44.009 --> 00:18:44.019 align:start position:0%
check was removed and now we can do some
 

00:18:44.019 --> 00:18:46.950 align:start position:0%
check was removed and now we can do some
more<00:18:44.230><c> things</c><00:18:44.499><c> we</c><00:18:45.309><c> again</c><00:18:45.669><c> explode</c><00:18:46.539><c> this</c>

00:18:46.950 --> 00:18:46.960 align:start position:0%
more things we again explode this
 

00:18:46.960 --> 00:18:49.200 align:start position:0%
more things we again explode this
complex<00:18:47.559><c> expression</c><00:18:48.100><c> into</c><00:18:48.429><c> multiple</c>

00:18:49.200 --> 00:18:49.210 align:start position:0%
complex expression into multiple
 

00:18:49.210 --> 00:18:52.799 align:start position:0%
complex expression into multiple
assignments<00:18:49.659><c> two</c><00:18:49.779><c> new</c><00:18:49.929><c> variables</c><00:18:50.080><c> and</c><00:18:51.809><c> ok</c>

00:18:52.799 --> 00:18:52.809 align:start position:0%
assignments two new variables and ok
 

00:18:52.809 --> 00:18:55.259 align:start position:0%
assignments two new variables and ok
this<00:18:52.960><c> is</c><00:18:53.139><c> this</c><00:18:53.889><c> is</c><00:18:54.009><c> I</c><00:18:54.070><c> think</c><00:18:54.100><c> the</c><00:18:54.369><c> most</c><00:18:54.610><c> tricky</c>

00:18:55.259 --> 00:18:55.269 align:start position:0%
this is this is I think the most tricky
 

00:18:55.269 --> 00:18:58.619 align:start position:0%
this is this is I think the most tricky
transformation<00:18:56.970><c> if</c><00:18:57.970><c> you</c><00:18:58.119><c> take</c><00:18:58.269><c> a</c><00:18:58.299><c> look</c><00:18:58.480><c> at</c>

00:18:58.619 --> 00:18:58.629 align:start position:0%
transformation if you take a look at
 

00:18:58.629 --> 00:19:04.230 align:start position:0%
transformation if you take a look at
underscore<00:18:59.139><c> 2</c><00:18:59.700><c> it</c><00:19:00.700><c> is</c><00:19:00.999><c> I</c><00:19:02.730><c> multiplied</c><00:19:03.730><c> by</c><00:19:04.029><c> hex</c>

00:19:04.230 --> 00:19:04.240 align:start position:0%
underscore 2 it is I multiplied by hex
 

00:19:04.240 --> 00:19:08.129 align:start position:0%
underscore 2 it is I multiplied by hex
20<00:19:04.629><c> or</c><00:19:04.899><c> by</c><00:19:05.049><c> x2</c><00:19:05.350><c> 0</c><00:19:05.559><c> and</c><00:19:06.190><c> I</c><00:19:07.149><c> is</c><00:19:07.210><c> the</c><00:19:07.659><c> loop</c>

00:19:08.129 --> 00:19:08.139 align:start position:0%
20 or by x2 0 and I is the loop
 

00:19:08.139 --> 00:19:11.509 align:start position:0%
20 or by x2 0 and I is the loop
iteration<00:19:08.769><c> counter</c><00:19:09.899><c> so</c><00:19:10.899><c> this</c><00:19:11.049><c> means</c>

00:19:11.509 --> 00:19:11.519 align:start position:0%
iteration counter so this means
 

00:19:11.519 --> 00:19:15.419 align:start position:0%
iteration counter so this means
underscore<00:19:12.519><c> 2</c><00:19:12.730><c> is</c><00:19:12.879><c> always</c><00:19:13.330><c> 0</c><00:19:14.019><c> X</c><00:19:14.200><c> 20</c><00:19:14.679><c> times</c><00:19:15.129><c> the</c>

00:19:15.419 --> 00:19:15.429 align:start position:0%
underscore 2 is always 0 X 20 times the
 

00:19:15.429 --> 00:19:17.820 align:start position:0%
underscore 2 is always 0 X 20 times the
number<00:19:15.669><c> of</c><00:19:15.759><c> iterations</c><00:19:16.299><c> and</c><00:19:16.529><c> we</c><00:19:17.529><c> know</c><00:19:17.649><c> that</c>

00:19:17.820 --> 00:19:17.830 align:start position:0%
number of iterations and we know that
 

00:19:17.830 --> 00:19:19.200 align:start position:0%
number of iterations and we know that
multiplication<00:19:18.220><c> is</c><00:19:18.549><c> more</c><00:19:18.759><c> expensive</c><00:19:19.029><c> than</c>

00:19:19.200 --> 00:19:19.210 align:start position:0%
multiplication is more expensive than
 

00:19:19.210 --> 00:19:23.759 align:start position:0%
multiplication is more expensive than
addition<00:19:19.559><c> but</c><00:19:20.820><c> as</c><00:19:21.820><c> the</c><00:19:22.059><c> code</c><00:19:22.210><c> is</c><00:19:22.539><c> here</c><00:19:23.169><c> now</c><00:19:23.379><c> we</c>

00:19:23.759 --> 00:19:23.769 align:start position:0%
addition but as the code is here now we
 

00:19:23.769 --> 00:19:27.149 align:start position:0%
addition but as the code is here now we
multiply<00:19:24.809><c> in</c><00:19:25.809><c> every</c><00:19:26.110><c> loop</c><00:19:26.289><c> iteration</c><00:19:26.889><c> anyway</c>

00:19:27.149 --> 00:19:27.159 align:start position:0%
multiply in every loop iteration anyway
 

00:19:27.159 --> 00:19:28.680 align:start position:0%
multiply in every loop iteration anyway
so<00:19:27.220><c> we</c><00:19:27.340><c> would</c><00:19:27.460><c> like</c><00:19:27.610><c> to</c><00:19:27.669><c> replace</c><00:19:28.210><c> the</c><00:19:28.480><c> vinyl</c>

00:19:28.680 --> 00:19:28.690 align:start position:0%
so we would like to replace the vinyl
 

00:19:28.690 --> 00:19:32.399 align:start position:0%
so we would like to replace the vinyl
edition<00:19:28.960><c> and</c><00:19:30.360><c> so</c><00:19:31.360><c> what</c><00:19:31.509><c> we</c><00:19:31.629><c> can</c><00:19:31.779><c> so</c><00:19:32.019><c> and</c><00:19:32.320><c> we</c>

00:19:32.399 --> 00:19:32.409 align:start position:0%
edition and so what we can so and we
 

00:19:32.409 --> 00:19:35.669 align:start position:0%
edition and so what we can so and we
know<00:19:32.610><c> underscore</c><00:19:33.610><c> 2</c><00:19:33.789><c> is</c><00:19:33.970><c> 0</c><00:19:34.570><c> X</c><00:19:34.720><c> 20</c><00:19:34.990><c> times</c><00:19:35.259><c> number</c>

00:19:35.669 --> 00:19:35.679 align:start position:0%
know underscore 2 is 0 X 20 times number
 

00:19:35.679 --> 00:19:38.549 align:start position:0%
know underscore 2 is 0 X 20 times number
of<00:19:35.740><c> iterations</c><00:19:36.190><c> so</c><00:19:36.450><c> we</c><00:19:37.450><c> can</c><00:19:37.690><c> write</c><00:19:38.320><c> in</c><00:19:38.470><c> a</c>

00:19:38.549 --> 00:19:38.559 align:start position:0%
of iterations so we can write in a
 

00:19:38.559 --> 00:19:41.039 align:start position:0%
of iterations so we can write in a
different<00:19:38.590><c> way</c><00:19:39.129><c> where</c><00:19:39.490><c> we</c><00:19:39.700><c> just</c><00:19:39.999><c> add</c><00:19:40.210><c> up</c><00:19:40.659><c> in</c>

00:19:41.039 --> 00:19:41.049 align:start position:0%
different way where we just add up in
 

00:19:41.049 --> 00:19:43.739 align:start position:0%
different way where we just add up in
every<00:19:41.619><c> iteration</c><00:19:41.860><c> and</c><00:19:42.369><c> it</c><00:19:42.700><c> will</c><00:19:42.879><c> it's</c><00:19:43.570><c> a</c><00:19:43.629><c> bit</c>

00:19:43.739 --> 00:19:43.749 align:start position:0%
every iteration and it will it's a bit
 

00:19:43.749 --> 00:19:46.200 align:start position:0%
every iteration and it will it's a bit
tricky<00:19:43.960><c> to</c><00:19:43.990><c> find</c><00:19:44.289><c> the</c><00:19:44.409><c> correct</c><00:19:44.619><c> start</c><00:19:45.009><c> so</c><00:19:45.580><c> we</c>

00:19:46.200 --> 00:19:46.210 align:start position:0%
tricky to find the correct start so we
 

00:19:46.210 --> 00:19:48.149 align:start position:0%
tricky to find the correct start so we
pull<00:19:46.480><c> out</c><00:19:46.629><c> this</c><00:19:46.840><c> under</c><00:19:47.139><c> code</c><00:19:47.350><c> underscore</c><00:19:47.950><c> 2</c>

00:19:48.149 --> 00:19:48.159 align:start position:0%
pull out this under code underscore 2
 

00:19:48.159 --> 00:19:49.980 align:start position:0%
pull out this under code underscore 2
outside<00:19:48.970><c> of</c><00:19:49.090><c> the</c><00:19:49.179><c> loop</c><00:19:49.330><c> and</c><00:19:49.480><c> store</c><00:19:49.690><c> we</c><00:19:49.840><c> have</c><00:19:49.960><c> to</c>

00:19:49.980 --> 00:19:49.990 align:start position:0%
outside of the loop and store we have to
 

00:19:49.990 --> 00:19:52.340 align:start position:0%
outside of the loop and store we have to
start<00:19:50.200><c> with</c><00:19:50.320><c> minus</c><00:19:50.740><c> 0</c><00:19:50.950><c> X</c><00:19:51.100><c> 20</c>

00:19:52.340 --> 00:19:52.350 align:start position:0%
start with minus 0 X 20
 

00:19:52.350 --> 00:19:54.710 align:start position:0%
start with minus 0 X 20
and<00:19:52.820><c> then</c><00:19:53.820><c> we</c><00:19:54.120><c> can</c><00:19:54.270><c> replace</c><00:19:54.419><c> the</c>

00:19:54.710 --> 00:19:54.720 align:start position:0%
and then we can replace the
 

00:19:54.720 --> 00:19:57.110 align:start position:0%
and then we can replace the
multiplication<00:19:55.380><c> by</c><00:19:55.500><c> an</c><00:19:55.590><c> addition</c><00:19:55.890><c> so</c><00:19:56.070><c> 2</c><00:19:56.429><c> is</c><00:19:56.669><c> 2</c>

00:19:57.110 --> 00:19:57.120 align:start position:0%
multiplication by an addition so 2 is 2
 

00:19:57.120 --> 00:20:04.760 align:start position:0%
multiplication by an addition so 2 is 2
plus<00:19:57.150><c> 0</c><00:19:57.840><c> X</c><00:19:57.900><c> 20</c><00:20:00.620><c> ok</c><00:20:03.080><c> yeah</c><00:20:04.080><c> if</c><00:20:04.500><c> you</c><00:20:04.590><c> look</c><00:20:04.710><c> at</c>

00:20:04.760 --> 00:20:04.770 align:start position:0%
plus 0 X 20 ok yeah if you look at
 

00:20:04.770 --> 00:20:06.590 align:start position:0%
plus 0 X 20 ok yeah if you look at
underscore<00:20:05.160><c> 3</c><00:20:05.370><c> that's</c><00:20:05.640><c> just</c><00:20:06.030><c> underscore</c><00:20:06.450><c> 2</c>

00:20:06.590 --> 00:20:06.600 align:start position:0%
underscore 3 that's just underscore 2
 

00:20:06.600 --> 00:20:10.010 align:start position:0%
underscore 3 that's just underscore 2
plus<00:20:07.020><c> data</c><00:20:07.669><c> so</c><00:20:08.669><c> this</c><00:20:09.059><c> is</c><00:20:09.210><c> kind</c><00:20:09.600><c> of</c><00:20:09.720><c> a</c><00:20:09.809><c> similar</c>

00:20:10.010 --> 00:20:10.020 align:start position:0%
plus data so this is kind of a similar
 

00:20:10.020 --> 00:20:14.000 align:start position:0%
plus data so this is kind of a similar
variable<00:20:10.650><c> or</c><00:20:11.520><c> in</c><00:20:12.419><c> other</c><00:20:12.600><c> words</c><00:20:12.840><c> these</c><00:20:13.710><c> are</c><00:20:13.890><c> all</c>

00:20:14.000 --> 00:20:14.010 align:start position:0%
variable or in other words these are all
 

00:20:14.010 --> 00:20:15.919 align:start position:0%
variable or in other words these are all
additions<00:20:14.520><c> so</c><00:20:14.940><c> they</c><00:20:15.090><c> are</c><00:20:15.210><c> all</c><00:20:15.360><c> associative</c>

00:20:15.919 --> 00:20:15.929 align:start position:0%
additions so they are all associative
 

00:20:15.929 --> 00:20:18.049 align:start position:0%
additions so they are all associative
which<00:20:16.230><c> means</c><00:20:16.470><c> we</c><00:20:16.710><c> can</c><00:20:16.860><c> pull</c><00:20:17.130><c> out</c><00:20:17.280><c> the</c><00:20:17.549><c> data</c><00:20:17.730><c> to</c>

00:20:18.049 --> 00:20:18.059 align:start position:0%
which means we can pull out the data to
 

00:20:18.059 --> 00:20:24.200 align:start position:0%
which means we can pull out the data to
the<00:20:18.090><c> very</c><00:20:18.390><c> beginning</c><00:20:21.320><c> yeah</c><00:20:22.490><c> so</c><00:20:23.490><c> underscore</c><00:20:24.030><c> 2</c>

00:20:24.200 --> 00:20:24.210 align:start position:0%
the very beginning yeah so underscore 2
 

00:20:24.210 --> 00:20:26.870 align:start position:0%
the very beginning yeah so underscore 2
is<00:20:24.450><c> so</c><00:20:24.900><c> we</c><00:20:25.020><c> know</c><00:20:25.409><c> the</c><00:20:25.559><c> data</c><00:20:25.710><c> is</c><00:20:25.980><c> added</c><00:20:26.280><c> to</c><00:20:26.490><c> 2</c><00:20:26.730><c> at</c>

00:20:26.870 --> 00:20:26.880 align:start position:0%
is so we know the data is added to 2 at
 

00:20:26.880 --> 00:20:28.430 align:start position:0%
is so we know the data is added to 2 at
the<00:20:27.000><c> very</c><00:20:27.150><c> beginning</c><00:20:27.570><c> and</c><00:20:27.750><c> not</c><00:20:27.960><c> anymore</c>

00:20:28.430 --> 00:20:28.440 align:start position:0%
the very beginning and not anymore
 

00:20:28.440 --> 00:20:33.529 align:start position:0%
the very beginning and not anymore
inside<00:20:28.950><c> the</c><00:20:29.100><c> loop</c><00:20:29.870><c> ok</c><00:20:31.400><c> and</c><00:20:32.400><c> I</c><00:20:33.210><c> think</c><00:20:33.390><c> that's</c>

00:20:33.529 --> 00:20:33.539 align:start position:0%
inside the loop ok and I think that's
 

00:20:33.539 --> 00:20:35.690 align:start position:0%
inside the loop ok and I think that's
almost<00:20:34.350><c> it</c><00:20:34.559><c> already</c><00:20:34.770><c> yeah</c><00:20:35.010><c> ok</c><00:20:35.250><c> another</c><00:20:35.549><c> thing</c>

00:20:35.690 --> 00:20:35.700 align:start position:0%
almost it already yeah ok another thing
 

00:20:35.700 --> 00:20:38.659 align:start position:0%
almost it already yeah ok another thing
we<00:20:35.909><c> can</c><00:20:36.030><c> do</c><00:20:36.179><c> is</c><00:20:36.950><c> if</c><00:20:37.950><c> you</c><00:20:38.039><c> look</c><00:20:38.190><c> at</c><00:20:38.309><c> the</c>

00:20:38.659 --> 00:20:38.669 align:start position:0%
we can do is if you look at the
 

00:20:38.669 --> 00:20:42.380 align:start position:0%
we can do is if you look at the
definition<00:20:38.820><c> of</c><00:20:39.150><c> underscore</c><00:20:39.510><c> 2</c><00:20:39.690><c> now</c><00:20:40.970><c> and</c><00:20:41.970><c> if</c>

00:20:42.380 --> 00:20:42.390 align:start position:0%
definition of underscore 2 now and if
 

00:20:42.390 --> 00:20:44.899 align:start position:0%
definition of underscore 2 now and if
you<00:20:42.600><c> insert</c><00:20:43.110><c> data</c><00:20:43.650><c> into</c><00:20:43.890><c> that</c><00:20:44.340><c> then</c><00:20:44.549><c> you</c><00:20:44.669><c> see</c>

00:20:44.899 --> 00:20:44.909 align:start position:0%
you insert data into that then you see
 

00:20:44.909 --> 00:20:53.060 align:start position:0%
you insert data into that then you see
this<00:20:45.210><c> is</c><00:20:45.390><c> x</c><00:20:46.049><c> +</c><00:20:46.620><c> 0</c><00:20:47.159><c> x</c><00:20:47.309><c> 20</c><00:20:47.700><c> -</c><00:20:48.330><c> 0</c><00:20:48.600><c> x</c><00:20:48.720><c> 20</c><00:20:51.440><c> so</c><00:20:52.440><c> we</c><00:20:52.770><c> can</c>

00:20:53.060 --> 00:20:53.070 align:start position:0%
this is x + 0 x 20 - 0 x 20 so we can
 

00:20:53.070 --> 00:20:58.100 align:start position:0%
this is x + 0 x 20 - 0 x 20 so we can
replace<00:20:53.929><c> underscore</c><00:20:54.929><c> 2</c><00:20:55.110><c> by</c><00:20:55.320><c> data</c><00:20:55.679><c> I</c><00:20:56.780><c> know</c><00:20:57.780><c> by</c><00:20:57.929><c> X</c>

00:20:58.100 --> 00:20:58.110 align:start position:0%
replace underscore 2 by data I know by X
 

00:20:58.110 --> 00:21:01.549 align:start position:0%
replace underscore 2 by data I know by X
of<00:20:58.260><c> course</c><00:20:58.470><c> yeah</c><00:20:58.650><c> so</c><00:20:58.830><c> it</c><00:20:58.919><c> was</c><00:20:59.039><c> x</c><00:20:59.309><c> +</c><00:20:59.610><c> 0</c><00:20:59.640><c> X</c><00:20:59.970><c> 2</c><00:21:00.659><c> 0</c><00:21:00.690><c> -</c><00:21:01.440><c> 3</c>

00:21:01.549 --> 00:21:01.559 align:start position:0%
of course yeah so it was x + 0 X 2 0 - 3
 

00:21:01.559 --> 00:21:05.870 align:start position:0%
of course yeah so it was x + 0 X 2 0 - 3
X<00:21:01.740><c> -</c><00:21:01.799><c> 0</c><00:21:01.919><c> so</c><00:21:02.250><c> it's</c><00:21:02.370><c> X</c><00:21:02.720><c> and</c><00:21:04.190><c> we</c><00:21:05.190><c> also</c><00:21:05.340><c> see</c><00:21:05.549><c> that</c><00:21:05.580><c> X</c>

00:21:05.870 --> 00:21:05.880 align:start position:0%
X - 0 so it's X and we also see that X
 

00:21:05.880 --> 00:21:09.320 align:start position:0%
X - 0 so it's X and we also see that X
is<00:21:06.059><c> unused</c><00:21:06.720><c> in</c><00:21:07.169><c> the</c><00:21:07.380><c> rest</c><00:21:07.530><c> of</c><00:21:07.710><c> the</c><00:21:07.830><c> program</c><00:21:08.330><c> so</c>

00:21:09.320 --> 00:21:09.330 align:start position:0%
is unused in the rest of the program so
 

00:21:09.330 --> 00:21:13.399 align:start position:0%
is unused in the rest of the program so
we<00:21:09.450><c> can</c><00:21:09.630><c> replace</c><00:21:10.169><c> underscore</c><00:21:11.100><c> 2</c><00:21:11.280><c> by</c><00:21:11.520><c> X</c><00:21:12.409><c> now</c>

00:21:13.399 --> 00:21:13.409 align:start position:0%
we can replace underscore 2 by X now
 

00:21:13.409 --> 00:21:16.430 align:start position:0%
we can replace underscore 2 by X now
that<00:21:13.860><c> was</c><00:21:14.010><c> the</c><00:21:14.130><c> next</c><00:21:14.309><c> step</c><00:21:14.929><c> we</c><00:21:15.929><c> see</c><00:21:16.110><c> that</c><00:21:16.230><c> data</c>

00:21:16.430 --> 00:21:16.440 align:start position:0%
that was the next step we see that data
 

00:21:16.440 --> 00:21:18.020 align:start position:0%
that was the next step we see that data
is<00:21:16.679><c> fully</c><00:21:16.950><c> unused</c><00:21:17.370><c> in</c><00:21:17.610><c> the</c><00:21:17.700><c> rest</c><00:21:17.850><c> of</c><00:21:17.970><c> the</c>

00:21:18.020 --> 00:21:18.030 align:start position:0%
is fully unused in the rest of the
 

00:21:18.030 --> 00:21:19.130 align:start position:0%
is fully unused in the rest of the
program<00:21:18.299><c> so</c><00:21:18.419><c> we</c><00:21:18.450><c> can</c><00:21:18.659><c> remove</c><00:21:18.870><c> it</c><00:21:19.020><c> altogether</c>

00:21:19.130 --> 00:21:19.140 align:start position:0%
program so we can remove it altogether
 

00:21:19.140 --> 00:21:20.659 align:start position:0%
program so we can remove it altogether
yeah

00:21:20.659 --> 00:21:20.669 align:start position:0%
yeah
 

00:21:20.669 --> 00:21:23.270 align:start position:0%
yeah
and<00:21:21.090><c> X</c><00:21:21.419><c> is</c><00:21:21.600><c> not</c><00:21:21.630><c> used</c><00:21:21.960><c> anymore</c><00:21:22.080><c> so</c><00:21:22.740><c> there's</c><00:21:22.980><c> no</c>

00:21:23.270 --> 00:21:23.280 align:start position:0%
and X is not used anymore so there's no
 

00:21:23.280 --> 00:21:26.570 align:start position:0%
and X is not used anymore so there's no
need<00:21:23.909><c> to</c><00:21:24.150><c> redefine</c><00:21:24.750><c> it</c><00:21:25.200><c> as</c><00:21:25.500><c> underscore</c><00:21:26.220><c> 2</c><00:21:26.370><c> so</c>

00:21:26.570 --> 00:21:26.580 align:start position:0%
need to redefine it as underscore 2 so
 

00:21:26.580 --> 00:21:29.870 align:start position:0%
need to redefine it as underscore 2 so
we<00:21:26.700><c> can</c><00:21:26.820><c> replace</c><00:21:26.970><c> underscore</c><00:21:27.450><c> 2</c><00:21:27.600><c> by</c><00:21:27.750><c> X</c><00:21:28.880><c> ok</c>

00:21:29.870 --> 00:21:29.880 align:start position:0%
we can replace underscore 2 by X ok
 

00:21:29.880 --> 00:21:33.649 align:start position:0%
we can replace underscore 2 by X ok
that's<00:21:30.330><c> almost</c><00:21:30.720><c> it</c><00:21:30.960><c> I</c><00:21:31.080><c> think</c><00:21:31.760><c> yeah</c><00:21:32.789><c> underscore</c>

00:21:33.649 --> 00:21:33.659 align:start position:0%
that's almost it I think yeah underscore
 

00:21:33.659 --> 00:21:36.169 align:start position:0%
that's almost it I think yeah underscore
one<00:21:33.900><c> is</c><00:21:34.260><c> only</c><00:21:34.440><c> used</c><00:21:34.710><c> one</c><00:21:34.980><c> so</c><00:21:35.280><c> we</c><00:21:35.429><c> can</c><00:21:35.580><c> inline</c><00:21:36.000><c> it</c>

00:21:36.169 --> 00:21:36.179 align:start position:0%
one is only used one so we can inline it
 

00:21:36.179 --> 00:21:39.980 align:start position:0%
one is only used one so we can inline it
back<00:21:36.419><c> into</c><00:21:36.600><c> the</c><00:21:36.780><c> expression</c><00:21:37.080><c> and</c><00:21:38.960><c> yeah</c><00:21:39.960><c> I</c>

00:21:39.980 --> 00:21:39.990 align:start position:0%
back into the expression and yeah I
 

00:21:39.990 --> 00:21:42.200 align:start position:0%
back into the expression and yeah I
would<00:21:40.380><c> claim</c><00:21:40.770><c> that</c><00:21:41.220><c> this</c><00:21:41.400><c> is</c><00:21:41.549><c> the</c><00:21:41.700><c> optimal</c>

00:21:42.200 --> 00:21:42.210 align:start position:0%
would claim that this is the optimal
 

00:21:42.210 --> 00:21:44.930 align:start position:0%
would claim that this is the optimal
program<00:21:42.960><c> the</c><00:21:43.679><c> only</c><00:21:43.710><c> thing</c><00:21:44.130><c> is</c><00:21:44.280><c> that</c><00:21:44.490><c> one</c>

00:21:44.930 --> 00:21:44.940 align:start position:0%
program the only thing is that one
 

00:21:44.940 --> 00:21:50.149 align:start position:0%
program the only thing is that one
already<00:21:45.539><c> mentioned</c><00:21:46.020><c> we</c><00:21:46.289><c> might</c><00:21:48.860><c> replace</c><00:21:49.860><c> the</c>

00:21:50.149 --> 00:21:50.159 align:start position:0%
already mentioned we might replace the
 

00:21:50.159 --> 00:21:54.470 align:start position:0%
already mentioned we might replace the
loop<00:21:51.030><c> iteration</c><00:21:51.600><c> variable</c><00:21:52.169><c> by</c><00:21:52.620><c> X</c><00:21:52.919><c> and</c><00:21:53.220><c> add</c><00:21:53.460><c> 0</c><00:21:54.240><c> X</c>

00:21:54.470 --> 00:21:54.480 align:start position:0%
loop iteration variable by X and add 0 X
 

00:21:54.480 --> 00:21:58.899 align:start position:0%
loop iteration variable by X and add 0 X
20<00:21:55.380><c> instead</c><00:21:55.740><c> of</c><00:21:55.830><c> 1</c><00:21:56.039><c> for</c><00:21:56.280><c> each</c><00:21:56.309><c> iteration</c><00:21:56.900><c> but</c>

00:21:58.899 --> 00:21:58.909 align:start position:0%
20 instead of 1 for each iteration but
 

00:21:58.909 --> 00:22:01.700 align:start position:0%
20 instead of 1 for each iteration but
yeah<00:21:59.909><c> if</c><00:22:00.750><c> you</c><00:22:00.960><c> do</c><00:22:01.049><c> that</c><00:22:01.230><c> then</c><00:22:01.380><c> we</c><00:22:01.470><c> would</c><00:22:01.620><c> have</c>

00:22:01.700 --> 00:22:01.710 align:start position:0%
yeah if you do that then we would have
 

00:22:01.710 --> 00:22:03.020 align:start position:0%
yeah if you do that then we would have
to<00:22:01.799><c> modify</c><00:22:02.070><c> length</c><00:22:02.400><c> we</c><00:22:02.700><c> would</c><00:22:02.820><c> have</c><00:22:02.940><c> to</c>

00:22:03.020 --> 00:22:03.030 align:start position:0%
to modify length we would have to
 

00:22:03.030 --> 00:22:05.870 align:start position:0%
to modify length we would have to
compare<00:22:03.360><c> against</c><00:22:03.780><c> length</c><00:22:04.049><c> x</c><00:22:04.470><c> 0</c><00:22:04.890><c> X</c><00:22:05.040><c> 20</c>

00:22:05.870 --> 00:22:05.880 align:start position:0%
compare against length x 0 X 20
 

00:22:05.880 --> 00:22:08.270 align:start position:0%
compare against length x 0 X 20
and<00:22:05.970><c> I</c><00:22:06.510><c> think</c><00:22:06.570><c> that</c><00:22:06.900><c> can</c><00:22:07.290><c> create</c><00:22:08.190><c> problems</c>

00:22:08.270 --> 00:22:08.280 align:start position:0%
and I think that can create problems
 

00:22:08.280 --> 00:22:14.000 align:start position:0%
and I think that can create problems
with<00:22:09.030><c> overflow</c><00:22:11.750><c> okay</c><00:22:12.750><c> that</c><00:22:13.380><c> was</c><00:22:13.530><c> an</c><00:22:13.680><c> example</c>

00:22:14.000 --> 00:22:14.010 align:start position:0%
with overflow okay that was an example
 

00:22:14.010 --> 00:22:16.850 align:start position:0%
with overflow okay that was an example
of<00:22:14.250><c> how</c><00:22:14.550><c> the</c><00:22:14.610><c> optimizer</c><00:22:15.150><c> operates</c><00:22:16.110><c> you</c><00:22:16.680><c> see</c>

00:22:16.850 --> 00:22:16.860 align:start position:0%
of how the optimizer operates you see
 

00:22:16.860 --> 00:22:18.890 align:start position:0%
of how the optimizer operates you see
that<00:22:17.010><c> the</c><00:22:17.100><c> resulting</c><00:22:17.490><c> program</c><00:22:17.790><c> is</c><00:22:17.910><c> really</c>

00:22:18.890 --> 00:22:18.900 align:start position:0%
that the resulting program is really
 

00:22:18.900 --> 00:22:21.620 align:start position:0%
that the resulting program is really
short<00:22:19.200><c> and</c><00:22:19.470><c> all</c><00:22:20.340><c> the</c><00:22:20.940><c> intermediate</c><00:22:21.210><c> steps</c>

00:22:21.620 --> 00:22:21.630 align:start position:0%
short and all the intermediate steps
 

00:22:21.630 --> 00:22:24.920 align:start position:0%
short and all the intermediate steps
were<00:22:22.370><c> quite</c><00:22:23.370><c> small</c>

00:22:24.920 --> 00:22:24.930 align:start position:0%
were quite small
 

00:22:24.930 --> 00:22:28.340 align:start position:0%
were quite small
another<00:22:25.830><c> thing</c><00:22:26.130><c> we</c><00:22:26.310><c> plan</c><00:22:26.640><c> to</c><00:22:26.880><c> do</c><00:22:27.030><c> is</c><00:22:27.350><c> memory</c>

00:22:28.340 --> 00:22:28.350 align:start position:0%
another thing we plan to do is memory
 

00:22:28.350 --> 00:22:32.060 align:start position:0%
another thing we plan to do is memory
optimizations<00:22:30.470><c> currently</c><00:22:31.470><c> solidity</c><00:22:31.830><c> does</c>

00:22:32.060 --> 00:22:32.070 align:start position:0%
optimizations currently solidity does
 

00:22:32.070 --> 00:22:33.710 align:start position:0%
optimizations currently solidity does
not<00:22:32.250><c> have</c><00:22:32.400><c> any</c><00:22:32.610><c> memory</c><00:22:32.880><c> management</c><00:22:33.210><c> because</c>

00:22:33.710 --> 00:22:33.720 align:start position:0%
not have any memory management because
 

00:22:33.720 --> 00:22:35.720 align:start position:0%
not have any memory management because
in<00:22:34.080><c> the</c><00:22:34.290><c> EVM</c><00:22:34.620><c> memory</c><00:22:34.950><c> is</c><00:22:35.070><c> usually</c><00:22:35.190><c> short-lived</c>

00:22:35.720 --> 00:22:35.730 align:start position:0%
in the EVM memory is usually short-lived
 

00:22:35.730 --> 00:22:38.000 align:start position:0%
in the EVM memory is usually short-lived
so<00:22:36.120><c> it</c><00:22:36.210><c> doesn't</c><00:22:36.540><c> make</c><00:22:37.080><c> sense</c><00:22:37.350><c> to</c><00:22:37.500><c> have</c><00:22:37.530><c> to</c><00:22:37.890><c> add</c>

00:22:38.000 --> 00:22:38.010 align:start position:0%
so it doesn't make sense to have to add
 

00:22:38.010 --> 00:22:40.760 align:start position:0%
so it doesn't make sense to have to add
the<00:22:38.220><c> huge</c><00:22:38.700><c> overhead</c><00:22:39.360><c> of</c><00:22:39.510><c> memory</c><00:22:39.810><c> management</c>

00:22:40.760 --> 00:22:40.770 align:start position:0%
the huge overhead of memory management
 

00:22:40.770 --> 00:22:43.610 align:start position:0%
the huge overhead of memory management
and<00:22:41.160><c> these</c><00:22:41.970><c> currently</c><00:22:42.510><c> results</c><00:22:43.020><c> in</c><00:22:43.230><c> some</c>

00:22:43.610 --> 00:22:43.620 align:start position:0%
and these currently results in some
 

00:22:43.620 --> 00:22:46.190 align:start position:0%
and these currently results in some
wasted<00:22:44.130><c> memory</c><00:22:44.510><c> especially</c><00:22:45.510><c> if</c><00:22:45.660><c> you</c><00:22:45.900><c> for</c>

00:22:46.190 --> 00:22:46.200 align:start position:0%
wasted memory especially if you for
 

00:22:46.200 --> 00:22:49.340 align:start position:0%
wasted memory especially if you for
example<00:22:46.230><c> if</c><00:22:46.560><c> you</c><00:22:46.650><c> allocate</c><00:22:47.070><c> a</c><00:22:48.020><c> memory</c><00:22:49.020><c> array</c>

00:22:49.340 --> 00:22:49.350 align:start position:0%
example if you allocate a memory array
 

00:22:49.350 --> 00:22:52.130 align:start position:0%
example if you allocate a memory array
inside<00:22:49.830><c> a</c><00:22:49.890><c> function</c><00:22:50.130><c> and</c><00:22:50.700><c> do</c><00:22:51.330><c> not</c><00:22:51.510><c> return</c><00:22:51.750><c> it</c>

00:22:52.130 --> 00:22:52.140 align:start position:0%
inside a function and do not return it
 

00:22:52.140 --> 00:22:53.630 align:start position:0%
inside a function and do not return it
so<00:22:52.260><c> you</c><00:22:52.320><c> basically</c><00:22:52.590><c> don't</c><00:22:52.800><c> really</c><00:22:53.430><c> use</c><00:22:53.610><c> it</c>

00:22:53.630 --> 00:22:53.640 align:start position:0%
so you basically don't really use it
 

00:22:53.640 --> 00:22:55.610 align:start position:0%
so you basically don't really use it
then<00:22:54.000><c> it</c><00:22:54.330><c> would</c><00:22:54.510><c> make</c><00:22:54.690><c> sense</c><00:22:54.900><c> to</c><00:22:55.020><c> free</c><00:22:55.410><c> the</c>

00:22:55.610 --> 00:22:55.620 align:start position:0%
then it would make sense to free the
 

00:22:55.620 --> 00:22:57.320 align:start position:0%
then it would make sense to free the
memory<00:22:55.770><c> again</c><00:22:56.190><c> after</c><00:22:56.910><c> the</c><00:22:57.000><c> end</c><00:22:57.120><c> of</c><00:22:57.240><c> the</c>

00:22:57.320 --> 00:22:57.330 align:start position:0%
memory again after the end of the
 

00:22:57.330 --> 00:23:00.170 align:start position:0%
memory again after the end of the
function<00:22:57.480><c> and</c><00:22:58.460><c> this</c><00:22:59.460><c> is</c><00:22:59.640><c> something</c><00:22:59.820><c> we</c>

00:23:00.170 --> 00:23:00.180 align:start position:0%
function and this is something we
 

00:23:00.180 --> 00:23:01.970 align:start position:0%
function and this is something we
believe<00:23:00.450><c> that</c><00:23:00.720><c> the</c><00:23:00.960><c> yule</c><00:23:01.110><c> optimizer</c><00:23:01.590><c> can</c><00:23:01.830><c> do</c>

00:23:01.970 --> 00:23:01.980 align:start position:0%
believe that the yule optimizer can do
 

00:23:01.980 --> 00:23:06.220 align:start position:0%
believe that the yule optimizer can do
when<00:23:02.250><c> we</c><00:23:02.370><c> introduce</c><00:23:02.820><c> yes</c><00:23:03.510><c> memory</c><00:23:04.410><c> objects</c><00:23:04.980><c> as</c>

00:23:06.220 --> 00:23:06.230 align:start position:0%
when we introduce yes memory objects as
 

00:23:06.230 --> 00:23:11.500 align:start position:0%
when we introduce yes memory objects as
yeah<00:23:07.230><c> first-class</c><00:23:07.620><c> citizens</c><00:23:10.250><c> there</c><00:23:11.250><c> is</c><00:23:11.400><c> a</c>

00:23:11.500 --> 00:23:11.510 align:start position:0%
yeah first-class citizens there is a
 

00:23:11.510 --> 00:23:14.270 align:start position:0%
yeah first-class citizens there is a
version<00:23:12.510><c> of</c><00:23:12.690><c> you</c><00:23:12.810><c> that</c><00:23:13.080><c> has</c><00:23:13.200><c> types</c><00:23:13.530><c> and</c><00:23:13.860><c> this</c>

00:23:14.270 --> 00:23:14.280 align:start position:0%
version of you that has types and this
 

00:23:14.280 --> 00:23:16.540 align:start position:0%
version of you that has types and this
would<00:23:14.520><c> fit</c><00:23:14.760><c> nicely</c><00:23:15.330><c> into</c><00:23:15.660><c> the</c><00:23:15.870><c> type</c><00:23:16.050><c> Kuehl</c>

00:23:16.540 --> 00:23:16.550 align:start position:0%
would fit nicely into the type Kuehl
 

00:23:16.550 --> 00:23:23.390 align:start position:0%
would fit nicely into the type Kuehl
dialect<00:23:18.680><c> yeah</c><00:23:19.680><c> so</c><00:23:20.060><c> as</c><00:23:21.060><c> a</c><00:23:21.930><c> summary</c><00:23:22.260><c> I</c><00:23:22.890><c> hope</c><00:23:23.220><c> that</c>

00:23:23.390 --> 00:23:23.400 align:start position:0%
dialect yeah so as a summary I hope that
 

00:23:23.400 --> 00:23:25.100 align:start position:0%
dialect yeah so as a summary I hope that
the<00:23:23.490><c> new</c><00:23:23.640><c> optimizer</c><00:23:24.090><c> will</c><00:23:24.330><c> be</c><00:23:24.420><c> safer</c><00:23:24.810><c> more</c>

00:23:25.100 --> 00:23:25.110 align:start position:0%
the new optimizer will be safer more
 

00:23:25.110 --> 00:23:26.840 align:start position:0%
the new optimizer will be safer more
transparent<00:23:25.590><c> and</c><00:23:25.620><c> more</c><00:23:25.710><c> powerful</c><00:23:26.250><c> the</c><00:23:26.610><c> main</c>

00:23:26.840 --> 00:23:26.850 align:start position:0%
transparent and more powerful the main
 

00:23:26.850 --> 00:23:28.160 align:start position:0%
transparent and more powerful the main
challenge<00:23:27.210><c> here</c><00:23:27.420><c> is</c><00:23:27.540><c> finding</c><00:23:28.110><c> good</c>

00:23:28.160 --> 00:23:28.170 align:start position:0%
challenge here is finding good
 

00:23:28.170 --> 00:23:31.610 align:start position:0%
challenge here is finding good
heuristics<00:23:28.710><c> per</c><00:23:28.950><c> step</c><00:23:29.130><c> as</c><00:23:29.520><c> I</c><00:23:29.640><c> explained</c><00:23:30.620><c> this</c>

00:23:31.610 --> 00:23:31.620 align:start position:0%
heuristics per step as I explained this
 

00:23:31.620 --> 00:23:36.950 align:start position:0%
heuristics per step as I explained this
will<00:23:32.010><c> not</c><00:23:32.130><c> impact</c><00:23:33.350><c> correctness</c><00:23:34.350><c> and</c><00:23:35.960><c> yeah</c>

00:23:36.950 --> 00:23:36.960 align:start position:0%
will not impact correctness and yeah
 

00:23:36.960 --> 00:23:40.430 align:start position:0%
will not impact correctness and yeah
code<00:23:37.950><c> size</c><00:23:38.280><c> is</c><00:23:38.580><c> always</c><00:23:38.850><c> an</c><00:23:38.940><c> important</c><00:23:39.440><c> measure</c>

00:23:40.430 --> 00:23:40.440 align:start position:0%
code size is always an important measure
 

00:23:40.440 --> 00:23:42.320 align:start position:0%
code size is always an important measure
whether<00:23:41.220><c> or</c><00:23:41.460><c> not</c><00:23:41.580><c> to</c><00:23:41.760><c> apply</c><00:23:41.940><c> some</c>

00:23:42.320 --> 00:23:42.330 align:start position:0%
whether or not to apply some
 

00:23:42.330 --> 00:23:44.810 align:start position:0%
whether or not to apply some
transformation<00:23:42.920><c> but</c><00:23:43.920><c> sometimes</c><00:23:44.520><c> it</c><00:23:44.670><c> makes</c>

00:23:44.810 --> 00:23:44.820 align:start position:0%
transformation but sometimes it makes
 

00:23:44.820 --> 00:23:48.370 align:start position:0%
transformation but sometimes it makes
sense<00:23:45.090><c> to</c><00:23:45.360><c> create</c><00:23:45.870><c> larger</c><00:23:46.320><c> court</c><00:23:46.590><c> larger</c><00:23:47.310><c> code</c>

00:23:48.370 --> 00:23:48.380 align:start position:0%
sense to create larger court larger code
 

00:23:48.380 --> 00:23:50.990 align:start position:0%
sense to create larger court larger code
in<00:23:49.380><c> intermediate</c><00:23:49.800><c> steps</c><00:23:50.190><c> that</c><00:23:50.580><c> can</c><00:23:50.820><c> be</c>

00:23:50.990 --> 00:23:51.000 align:start position:0%
in intermediate steps that can be
 

00:23:51.000 --> 00:23:58.930 align:start position:0%
in intermediate steps that can be
reduced<00:23:51.240><c> to</c><00:23:51.450><c> even</c><00:23:51.750><c> shorter</c><00:23:52.200><c> code</c><00:23:52.380><c> later</c><00:23:57.740><c> yeah</c>

00:23:58.930 --> 00:23:58.940 align:start position:0%
reduced to even shorter code later yeah
 

00:23:58.940 --> 00:24:02.210 align:start position:0%
reduced to even shorter code later yeah
just<00:23:59.940><c> some</c><00:24:00.180><c> quick</c><00:24:00.480><c> words</c><00:24:00.690><c> on</c><00:24:00.870><c> the</c><00:24:01.020><c> roadmap</c><00:24:01.230><c> we</c>

00:24:02.210 --> 00:24:02.220 align:start position:0%
just some quick words on the roadmap we
 

00:24:02.220 --> 00:24:05.300 align:start position:0%
just some quick words on the roadmap we
currently<00:24:02.640><c> implemented</c><00:24:03.770><c> most</c><00:24:04.770><c> of</c><00:24:05.010><c> the</c><00:24:05.100><c> steps</c>

00:24:05.300 --> 00:24:05.310 align:start position:0%
currently implemented most of the steps
 

00:24:05.310 --> 00:24:09.320 align:start position:0%
currently implemented most of the steps
we've<00:24:05.520><c> seen</c><00:24:05.850><c> here</c><00:24:06.240><c> apart</c><00:24:06.720><c> from</c><00:24:07.370><c> the</c><00:24:08.370><c> two</c><00:24:09.180><c> or</c>

00:24:09.320 --> 00:24:09.330 align:start position:0%
we've seen here apart from the two or
 

00:24:09.330 --> 00:24:11.780 align:start position:0%
we've seen here apart from the two or
three<00:24:09.510><c> loop</c><00:24:09.900><c> transformations</c><00:24:10.460><c> we've</c><00:24:11.460><c> seen</c>

00:24:11.780 --> 00:24:11.790 align:start position:0%
three loop transformations we've seen
 

00:24:11.790 --> 00:24:16.340 align:start position:0%
three loop transformations we've seen
and<00:24:12.320><c> now</c><00:24:13.320><c> the</c><00:24:13.380><c> next</c><00:24:14.190><c> step</c><00:24:14.340><c> is</c><00:24:14.580><c> to</c><00:24:15.350><c> implement</c>

00:24:16.340 --> 00:24:16.350 align:start position:0%
and now the next step is to implement
 

00:24:16.350 --> 00:24:19.930 align:start position:0%
and now the next step is to implement
these<00:24:16.620><c> loop</c><00:24:17.130><c> transformations</c><00:24:17.610><c> too</c><00:24:18.090><c> and</c>

00:24:19.930 --> 00:24:19.940 align:start position:0%
these loop transformations too and
 

00:24:19.940 --> 00:24:22.129 align:start position:0%
these loop transformations too and
check<00:24:20.940><c> that</c><00:24:21.149><c> all</c><00:24:21.389><c> the</c><00:24:21.419><c> transformations</c><00:24:22.019><c> are</c>

00:24:22.129 --> 00:24:22.139 align:start position:0%
check that all the transformations are
 

00:24:22.139 --> 00:24:25.580 align:start position:0%
check that all the transformations are
correct<00:24:22.940><c> and</c><00:24:23.940><c> then</c><00:24:24.240><c> we</c><00:24:24.450><c> will</c><00:24:24.629><c> apply</c><00:24:25.139><c> that</c><00:24:25.230><c> to</c>

00:24:25.580 --> 00:24:25.590 align:start position:0%
correct and then we will apply that to
 

00:24:25.590 --> 00:24:28.220 align:start position:0%
correct and then we will apply that to
the<00:24:25.710><c> a</c><00:24:25.740><c> bi</c><00:24:26.009><c> coder</c><00:24:26.549><c> take</c><00:24:26.999><c> the</c><00:24:27.179><c> ABI</c><00:24:27.419><c> KOTOR</c><00:24:27.990><c> out</c><00:24:28.110><c> of</c>

00:24:28.220 --> 00:24:28.230 align:start position:0%
the a bi coder take the ABI KOTOR out of
 

00:24:28.230 --> 00:24:32.840 align:start position:0%
the a bi coder take the ABI KOTOR out of
experimental<00:24:28.830><c> and</c><00:24:29.059><c> then</c><00:24:31.190><c> ya</c><00:24:32.190><c> make</c><00:24:32.669><c> the</c>

00:24:32.840 --> 00:24:32.850 align:start position:0%
experimental and then ya make the
 

00:24:32.850 --> 00:24:36.230 align:start position:0%
experimental and then ya make the
rewrite<00:24:33.240><c> of</c><00:24:33.269><c> the</c><00:24:33.509><c> solidity</c><00:24:34.379><c> compiler</c><00:24:34.830><c> and</c><00:24:35.240><c> at</c>

00:24:36.230 --> 00:24:36.240 align:start position:0%
rewrite of the solidity compiler and at
 

00:24:36.240 --> 00:24:39.470 align:start position:0%
rewrite of the solidity compiler and at
that<00:24:36.480><c> point</c><00:24:36.919><c> also</c><00:24:37.919><c> other</c><00:24:38.700><c> steps</c><00:24:38.999><c> might</c><00:24:39.299><c> make</c>

00:24:39.470 --> 00:24:39.480 align:start position:0%
that point also other steps might make
 

00:24:39.480 --> 00:24:41.659 align:start position:0%
that point also other steps might make
sense<00:24:39.690><c> that</c><00:24:39.899><c> do</c><00:24:39.990><c> not</c><00:24:40.110><c> make</c><00:24:40.289><c> sense</c><00:24:40.350><c> in</c><00:24:40.860><c> the</c><00:24:41.340><c> ABI</c>

00:24:41.659 --> 00:24:41.669 align:start position:0%
sense that do not make sense in the ABI
 

00:24:41.669 --> 00:24:44.149 align:start position:0%
sense that do not make sense in the ABI
coder<00:24:41.999><c> so</c><00:24:42.120><c> we</c><00:24:42.419><c> will</c><00:24:42.600><c> continually</c><00:24:43.350><c> improve</c><00:24:43.830><c> the</c>

00:24:44.149 --> 00:24:44.159 align:start position:0%
coder so we will continually improve the
 

00:24:44.159 --> 00:24:46.549 align:start position:0%
coder so we will continually improve the
optimizer<00:24:44.999><c> there</c><00:24:45.409><c> thanks</c><00:24:46.409><c> for</c><00:24:46.499><c> your</c>

00:24:46.549 --> 00:24:46.559 align:start position:0%
optimizer there thanks for your
 

00:24:46.559 --> 00:24:47.610 align:start position:0%
optimizer there thanks for your
attention

00:24:47.610 --> 00:24:47.620 align:start position:0%
attention
 

00:24:47.620 --> 00:24:59.170 align:start position:0%
attention
[Applause]

00:24:59.170 --> 00:24:59.180 align:start position:0%
 
 

00:24:59.180 --> 00:25:01.240 align:start position:0%
 
you

