WEBVTT
Kind: captions
Language: en

00:00:09.190 --> 00:00:16.529 align:start position:0%
 
[Music]

00:00:16.529 --> 00:00:16.539 align:start position:0%
[Music]
 

00:00:16.539 --> 00:00:20.290 align:start position:0%
[Music]
yeah<00:00:17.539><c> hello</c><00:00:17.990><c> everyone</c><00:00:18.790><c> so</c><00:00:19.790><c> I'm</c><00:00:19.880><c> going</c><00:00:20.060><c> to</c><00:00:20.090><c> talk</c>

00:00:20.290 --> 00:00:20.300 align:start position:0%
yeah hello everyone so I'm going to talk
 

00:00:20.300 --> 00:00:22.840 align:start position:0%
yeah hello everyone so I'm going to talk
about<00:00:20.450><c> Julia</c><00:00:20.980><c> which</c><00:00:21.980><c> is</c><00:00:22.160><c> an</c><00:00:22.310><c> intermediate</c>

00:00:22.840 --> 00:00:22.850 align:start position:0%
about Julia which is an intermediate
 

00:00:22.850 --> 00:00:24.910 align:start position:0%
about Julia which is an intermediate
representation<00:00:23.630><c> or</c><00:00:23.840><c> an</c><00:00:24.170><c> intermediate</c>

00:00:24.910 --> 00:00:24.920 align:start position:0%
representation or an intermediate
 

00:00:24.920 --> 00:00:29.200 align:start position:0%
representation or an intermediate
language<00:00:25.090><c> for</c><00:00:26.090><c> ATM</c><00:00:26.510><c> contracts</c><00:00:28.180><c> you</c><00:00:29.180><c> know</c>

00:00:29.200 --> 00:00:29.210 align:start position:0%
language for ATM contracts you know
 

00:00:29.210 --> 00:00:31.090 align:start position:0%
language for ATM contracts you know
let's<00:00:29.480><c> just</c><00:00:29.570><c> first</c><00:00:29.840><c> see</c><00:00:30.110><c> what</c><00:00:30.800><c> are</c><00:00:30.950><c> the</c>

00:00:31.090 --> 00:00:31.100 align:start position:0%
let's just first see what are the
 

00:00:31.100 --> 00:00:33.400 align:start position:0%
let's just first see what are the
problems<00:00:31.550><c> why</c><00:00:31.789><c> would</c><00:00:32.210><c> we</c><00:00:32.360><c> need</c><00:00:32.599><c> a</c><00:00:32.840><c> new</c>

00:00:33.400 --> 00:00:33.410 align:start position:0%
problems why would we need a new
 

00:00:33.410 --> 00:00:35.530 align:start position:0%
problems why would we need a new
language<00:00:33.590><c> or</c><00:00:34.160><c> am</c><00:00:34.550><c> I</c><00:00:34.640><c> just</c><00:00:34.670><c> crazy</c><00:00:34.970><c> that</c><00:00:35.240><c> we</c><00:00:35.420><c> need</c>

00:00:35.530 --> 00:00:35.540 align:start position:0%
language or am I just crazy that we need
 

00:00:35.540 --> 00:00:39.310 align:start position:0%
language or am I just crazy that we need
a<00:00:35.570><c> new</c><00:00:35.750><c> language</c><00:00:37.540><c> in</c><00:00:38.540><c> fact</c><00:00:38.810><c> we</c><00:00:38.990><c> do</c><00:00:39.140><c> have</c><00:00:39.290><c> a</c>

00:00:39.310 --> 00:00:39.320 align:start position:0%
a new language in fact we do have a
 

00:00:39.320 --> 00:00:41.140 align:start position:0%
a new language in fact we do have a
couple<00:00:39.500><c> of</c><00:00:39.680><c> problems</c><00:00:39.920><c> and</c><00:00:40.340><c> most</c><00:00:40.940><c> of</c><00:00:41.060><c> these</c>

00:00:41.140 --> 00:00:41.150 align:start position:0%
couple of problems and most of these
 

00:00:41.150 --> 00:00:43.030 align:start position:0%
couple of problems and most of these
problems<00:00:41.450><c> actually</c><00:00:42.170><c> related</c><00:00:42.800><c> to</c><00:00:42.950><c> the</c>

00:00:43.030 --> 00:00:43.040 align:start position:0%
problems actually related to the
 

00:00:43.040 --> 00:00:45.729 align:start position:0%
problems actually related to the
solidity<00:00:43.400><c> compiler</c><00:00:43.910><c> itself</c><00:00:44.560><c> the</c><00:00:45.560><c> first</c>

00:00:45.729 --> 00:00:45.739 align:start position:0%
solidity compiler itself the first
 

00:00:45.739 --> 00:00:48.580 align:start position:0%
solidity compiler itself the first
problem<00:00:46.160><c> is</c><00:00:46.310><c> you</c><00:00:46.970><c> know</c><00:00:47.060><c> auditing</c><00:00:47.600><c> contracts</c>

00:00:48.580 --> 00:00:48.590 align:start position:0%
problem is you know auditing contracts
 

00:00:48.590 --> 00:00:51.460 align:start position:0%
problem is you know auditing contracts
written<00:00:49.010><c> in</c><00:00:49.280><c> solidity</c><00:00:49.670><c> is</c><00:00:50.000><c> not</c><00:00:50.600><c> that</c><00:00:50.810><c> simple</c><00:00:51.050><c> I</c>

00:00:51.460 --> 00:00:51.470 align:start position:0%
written in solidity is not that simple I
 

00:00:51.470 --> 00:00:54.790 align:start position:0%
written in solidity is not that simple I
will<00:00:51.800><c> explain</c><00:00:52.190><c> that</c><00:00:52.250><c> in</c><00:00:52.430><c> a</c><00:00:52.579><c> bit</c><00:00:53.290><c> then</c><00:00:54.320><c> the</c>

00:00:54.790 --> 00:00:54.800 align:start position:0%
will explain that in a bit then the
 

00:00:54.800 --> 00:00:57.700 align:start position:0%
will explain that in a bit then the
solidity<00:00:55.220><c> compiler</c><00:00:55.670><c> is</c><00:00:55.880><c> written</c><00:00:56.210><c> in</c><00:00:56.300><c> C++</c><00:00:56.710><c> and</c>

00:00:57.700 --> 00:00:57.710 align:start position:0%
solidity compiler is written in C++ and
 

00:00:57.710 --> 00:01:00.430 align:start position:0%
solidity compiler is written in C++ and
a<00:00:57.980><c> lot</c><00:00:58.100><c> of</c><00:00:58.220><c> things</c><00:00:58.489><c> a</c><00:00:58.820><c> lot</c><00:00:58.850><c> of</c><00:00:59.390><c> helpers</c><00:00:59.960><c> lot</c><00:01:00.320><c> of</c>

00:01:00.430 --> 00:01:00.440 align:start position:0%
a lot of things a lot of helpers lot of
 

00:01:00.440 --> 00:01:02.590 align:start position:0%
a lot of things a lot of helpers lot of
code<00:01:01.070><c> generators</c><00:01:01.700><c> are</c><00:01:02.090><c> of</c><00:01:02.210><c> course</c><00:01:02.420><c> between</c>

00:01:02.590 --> 00:01:02.600 align:start position:0%
code generators are of course between
 

00:01:02.600 --> 00:01:05.860 align:start position:0%
code generators are of course between
C++<00:01:03.380><c> and</c><00:01:03.590><c> they</c><00:01:04.009><c> are</c><00:01:04.129><c> quite</c><00:01:04.640><c> complex</c><00:01:05.119><c> and</c><00:01:05.780><c> you</c>

00:01:05.860 --> 00:01:05.870 align:start position:0%
C++ and they are quite complex and you
 

00:01:05.870 --> 00:01:07.630 align:start position:0%
C++ and they are quite complex and you
know<00:01:05.930><c> with</c><00:01:06.080><c> time</c><00:01:06.229><c> they</c><00:01:06.409><c> can</c><00:01:06.620><c> become</c><00:01:06.770><c> even</c><00:01:07.610><c> more</c>

00:01:07.630 --> 00:01:07.640 align:start position:0%
know with time they can become even more
 

00:01:07.640 --> 00:01:10.870 align:start position:0%
know with time they can become even more
complex<00:01:08.210><c> as</c><00:01:08.330><c> more</c><00:01:08.510><c> features</c><00:01:08.960><c> are</c><00:01:09.200><c> added</c><00:01:09.880><c> the</c>

00:01:10.870 --> 00:01:10.880 align:start position:0%
complex as more features are added the
 

00:01:10.880 --> 00:01:13.780 align:start position:0%
complex as more features are added the
next<00:01:11.120><c> problem</c><00:01:11.299><c> is</c><00:01:11.979><c> optimizations</c><00:01:12.979><c> you</c><00:01:13.670><c> know</c>

00:01:13.780 --> 00:01:13.790 align:start position:0%
next problem is optimizations you know
 

00:01:13.790 --> 00:01:16.270 align:start position:0%
next problem is optimizations you know
different<00:01:14.090><c> optimization</c><00:01:14.750><c> steps</c><00:01:15.080><c> on</c><00:01:15.500><c> the</c>

00:01:16.270 --> 00:01:16.280 align:start position:0%
different optimization steps on the
 

00:01:16.280 --> 00:01:18.820 align:start position:0%
different optimization steps on the
compilation<00:01:16.580><c> that</c><00:01:17.510><c> can</c><00:01:17.750><c> become</c><00:01:17.930><c> very</c><00:01:18.470><c> complex</c>

00:01:18.820 --> 00:01:18.830 align:start position:0%
compilation that can become very complex
 

00:01:18.830 --> 00:01:23.350 align:start position:0%
compilation that can become very complex
as<00:01:19.010><c> well</c><00:01:20.710><c> this</c><00:01:21.710><c> one</c><00:01:21.950><c> so</c><00:01:22.490><c> far</c><00:01:22.520><c> hasn't</c><00:01:22.970><c> been</c><00:01:23.240><c> an</c>

00:01:23.350 --> 00:01:23.360 align:start position:0%
as well this one so far hasn't been an
 

00:01:23.360 --> 00:01:26.260 align:start position:0%
as well this one so far hasn't been an
issue<00:01:23.510><c> because</c><00:01:23.900><c> solidity</c><00:01:24.560><c> can</c><00:01:25.369><c> only</c><00:01:25.640><c> output</c>

00:01:26.260 --> 00:01:26.270 align:start position:0%
issue because solidity can only output
 

00:01:26.270 --> 00:01:29.050 align:start position:0%
issue because solidity can only output
evm<00:01:27.020><c> bytecode</c><00:01:27.560><c> but</c><00:01:28.400><c> you</c><00:01:28.520><c> know</c><00:01:28.610><c> in</c><00:01:28.700><c> the</c><00:01:28.790><c> feech</c>

00:01:29.050 --> 00:01:29.060 align:start position:0%
evm bytecode but you know in the feech
 

00:01:29.060 --> 00:01:32.350 align:start position:0%
evm bytecode but you know in the feech
future<00:01:29.869><c> we</c><00:01:30.320><c> might</c><00:01:30.530><c> move</c><00:01:30.680><c> on</c><00:01:30.860><c> to</c><00:01:31.070><c> new</c><00:01:31.880><c> virtual</c>

00:01:32.350 --> 00:01:32.360 align:start position:0%
future we might move on to new virtual
 

00:01:32.360 --> 00:01:35.050 align:start position:0%
future we might move on to new virtual
machines<00:01:32.840><c> so</c><00:01:33.049><c> one</c><00:01:33.950><c> such</c><00:01:34.189><c> virtual</c><00:01:34.549><c> machine</c><00:01:34.820><c> is</c>

00:01:35.050 --> 00:01:35.060 align:start position:0%
machines so one such virtual machine is
 

00:01:35.060 --> 00:01:37.750 align:start position:0%
machines so one such virtual machine is
called<00:01:35.330><c> a</c><00:01:35.570><c> vm</c><00:01:35.810><c> 1.5</c><00:01:36.500><c> and</c><00:01:36.830><c> that</c><00:01:37.430><c> one</c><00:01:37.580><c> is</c><00:01:37.670><c> called</c>

00:01:37.750 --> 00:01:37.760 align:start position:0%
called a vm 1.5 and that one is called
 

00:01:37.760 --> 00:01:40.510 align:start position:0%
called a vm 1.5 and that one is called
it<00:01:38.119><c> wasn't</c><00:01:38.540><c> in</c><00:01:39.350><c> the</c><00:01:39.439><c> current</c><00:01:39.770><c> state</c><00:01:40.490><c> of</c>

00:01:40.510 --> 00:01:40.520 align:start position:0%
it wasn't in the current state of
 

00:01:40.520 --> 00:01:43.240 align:start position:0%
it wasn't in the current state of
solidity<00:01:41.320><c> there</c><00:01:42.320><c> would</c><00:01:42.500><c> be</c><00:01:42.530><c> a</c><00:01:42.650><c> quiet</c><00:01:42.950><c> big</c>

00:01:43.240 --> 00:01:43.250 align:start position:0%
solidity there would be a quiet big
 

00:01:43.250 --> 00:01:44.649 align:start position:0%
solidity there would be a quiet big
change<00:01:43.610><c> to</c><00:01:43.850><c> rewrite</c><00:01:44.150><c> the</c><00:01:44.299><c> compiler</c>

00:01:44.649 --> 00:01:44.659 align:start position:0%
change to rewrite the compiler
 

00:01:44.659 --> 00:01:48.700 align:start position:0%
change to rewrite the compiler
supporting<00:01:45.439><c> any</c><00:01:45.799><c> of</c><00:01:45.950><c> those</c><00:01:46.210><c> and</c><00:01:47.710><c> lastly</c>

00:01:48.700 --> 00:01:48.710 align:start position:0%
supporting any of those and lastly
 

00:01:48.710 --> 00:01:50.789 align:start position:0%
supporting any of those and lastly
creating<00:01:49.250><c> the</c><00:01:49.520><c> cells</c><00:01:49.909><c> or</c><00:01:50.330><c> domain-specific</c>

00:01:50.789 --> 00:01:50.799 align:start position:0%
creating the cells or domain-specific
 

00:01:50.799 --> 00:01:54.190 align:start position:0%
creating the cells or domain-specific
languages<00:01:51.850><c> it</c><00:01:52.850><c> doesn't</c><00:01:53.360><c> really</c><00:01:53.479><c> exist</c><00:01:53.659><c> at</c><00:01:54.049><c> the</c>

00:01:54.190 --> 00:01:54.200 align:start position:0%
languages it doesn't really exist at the
 

00:01:54.200 --> 00:01:56.920 align:start position:0%
languages it doesn't really exist at the
moment<00:01:54.530><c> and</c><00:01:54.820><c> the</c><00:01:55.820><c> most</c><00:01:56.060><c> practical</c><00:01:56.570><c> way</c><00:01:56.600><c> to</c><00:01:56.689><c> do</c>

00:01:56.920 --> 00:01:56.930 align:start position:0%
moment and the most practical way to do
 

00:01:56.930 --> 00:01:59.170 align:start position:0%
moment and the most practical way to do
that<00:01:57.110><c> is</c><00:01:57.340><c> to</c><00:01:58.340><c> compile</c><00:01:58.700><c> a</c><00:01:58.729><c> domain-specific</c>

00:01:59.170 --> 00:01:59.180 align:start position:0%
that is to compile a domain-specific
 

00:01:59.180 --> 00:02:03.280 align:start position:0%
that is to compile a domain-specific
language<00:01:59.960><c> -</c><00:02:00.560><c> solidity</c><00:02:01.009><c> or</c><00:02:01.640><c> -</c><00:02:01.880><c> serpent</c><00:02:02.329><c> and</c><00:02:02.659><c> by</c>

00:02:03.280 --> 00:02:03.290 align:start position:0%
language - solidity or - serpent and by
 

00:02:03.290 --> 00:02:04.929 align:start position:0%
language - solidity or - serpent and by
doing<00:02:03.470><c> that</c><00:02:03.590><c> you</c><00:02:04.070><c> will</c><00:02:04.189><c> be</c><00:02:04.340><c> exposed</c><00:02:04.549><c> to</c><00:02:04.820><c> the</c>

00:02:04.929 --> 00:02:04.939 align:start position:0%
doing that you will be exposed to the
 

00:02:04.939 --> 00:02:07.420 align:start position:0%
doing that you will be exposed to the
very<00:02:05.030><c> same</c><00:02:05.329><c> problems</c><00:02:05.810><c> solidity</c><00:02:06.710><c> is</c><00:02:06.829><c> exposed</c>

00:02:07.420 --> 00:02:07.430 align:start position:0%
very same problems solidity is exposed
 

00:02:07.430 --> 00:02:11.140 align:start position:0%
very same problems solidity is exposed
to<00:02:08.649><c> so</c><00:02:09.649><c> this</c><00:02:09.890><c> is</c><00:02:09.950><c> one</c><00:02:10.280><c> of</c><00:02:10.310><c> the</c><00:02:10.520><c> example</c><00:02:10.970><c> for</c>

00:02:11.140 --> 00:02:11.150 align:start position:0%
to so this is one of the example for
 

00:02:11.150 --> 00:02:13.839 align:start position:0%
to so this is one of the example for
auditing<00:02:11.750><c> right</c><00:02:12.709><c> the</c><00:02:13.099><c> multiple</c><00:02:13.489><c> parts</c><00:02:13.730><c> do</c>

00:02:13.839 --> 00:02:13.849 align:start position:0%
auditing right the multiple parts do
 

00:02:13.849 --> 00:02:14.890 align:start position:0%
auditing right the multiple parts do
auditing

00:02:14.890 --> 00:02:14.900 align:start position:0%
auditing
 

00:02:14.900 --> 00:02:17.080 align:start position:0%
auditing
before<00:02:15.230><c> one</c><00:02:15.739><c> needs</c><00:02:15.890><c> to</c><00:02:16.040><c> make</c><00:02:16.129><c> sure</c><00:02:16.189><c> that</c><00:02:17.030><c> the</c>

00:02:17.080 --> 00:02:17.090 align:start position:0%
before one needs to make sure that the
 

00:02:17.090 --> 00:02:19.539 align:start position:0%
before one needs to make sure that the
contract<00:02:17.540><c> written</c><00:02:17.659><c> solidity</c><00:02:18.260><c> does</c><00:02:19.099><c> what</c><00:02:19.519><c> a</c>

00:02:19.539 --> 00:02:19.549 align:start position:0%
contract written solidity does what a
 

00:02:19.549 --> 00:02:22.089 align:start position:0%
contract written solidity does what a
functional<00:02:19.970><c> specification</c><00:02:20.120><c> says</c><00:02:20.989><c> in</c><00:02:21.379><c> this</c>

00:02:22.089 --> 00:02:22.099 align:start position:0%
functional specification says in this
 

00:02:22.099 --> 00:02:26.289 align:start position:0%
functional specification says in this
case<00:02:22.569><c> the</c><00:02:23.569><c> intention</c><00:02:24.019><c> was</c><00:02:24.230><c> to</c><00:02:24.790><c> being</c><00:02:25.790><c> able</c><00:02:26.060><c> to</c>

00:02:26.289 --> 00:02:26.299 align:start position:0%
case the intention was to being able to
 

00:02:26.299 --> 00:02:28.809 align:start position:0%
case the intention was to being able to
redeem<00:02:26.569><c> the</c><00:02:27.049><c> money</c><00:02:27.230><c> once</c><00:02:27.500><c> but</c><00:02:28.370><c> I</c><00:02:28.400><c> don't</c><00:02:28.519><c> think</c>

00:02:28.809 --> 00:02:28.819 align:start position:0%
redeem the money once but I don't think
 

00:02:28.819 --> 00:02:32.020 align:start position:0%
redeem the money once but I don't think
the<00:02:28.970><c> contract</c><00:02:29.360><c> does</c><00:02:29.510><c> did</c><00:02:30.519><c> the</c><00:02:31.519><c> second</c><00:02:31.879><c> problem</c>

00:02:32.020 --> 00:02:32.030 align:start position:0%
the contract does did the second problem
 

00:02:32.030 --> 00:02:34.300 align:start position:0%
the contract does did the second problem
with<00:02:32.239><c> auditing</c><00:02:32.750><c> which</c><00:02:33.560><c> might</c><00:02:33.769><c> not</c><00:02:33.859><c> be</c><00:02:33.920><c> done</c><00:02:34.159><c> in</c>

00:02:34.300 --> 00:02:34.310 align:start position:0%
with auditing which might not be done in
 

00:02:34.310 --> 00:02:37.330 align:start position:0%
with auditing which might not be done in
every<00:02:34.430><c> single</c><00:02:34.849><c> case</c><00:02:35.120><c> is</c><00:02:36.010><c> verifying</c><00:02:37.010><c> that</c><00:02:37.129><c> the</c>

00:02:37.330 --> 00:02:37.340 align:start position:0%
every single case is verifying that the
 

00:02:37.340 --> 00:02:40.599 align:start position:0%
every single case is verifying that the
compiler<00:02:37.790><c> creates</c><00:02:38.569><c> byte</c><00:02:39.019><c> code</c><00:02:39.609><c> accordingly</c>

00:02:40.599 --> 00:02:40.609 align:start position:0%
compiler creates byte code accordingly
 

00:02:40.609 --> 00:02:43.539 align:start position:0%
compiler creates byte code accordingly
to<00:02:41.390><c> the</c><00:02:41.510><c> source</c><00:02:41.720><c> code</c><00:02:42.250><c> so</c><00:02:43.250><c> there</c><00:02:43.400><c> are</c><00:02:43.459><c> two</c>

00:02:43.539 --> 00:02:43.549 align:start position:0%
to the source code so there are two
 

00:02:43.549 --> 00:02:47.410 align:start position:0%
to the source code so there are two
examples<00:02:44.060><c> there</c><00:02:44.269><c> the</c><00:02:44.900><c> top</c><00:02:45.079><c> one</c><00:02:45.319><c> is</c><00:02:45.500><c> a</c><00:02:46.420><c> assembly</c>

00:02:47.410 --> 00:02:47.420 align:start position:0%
examples there the top one is a assembly
 

00:02:47.420 --> 00:02:51.849 align:start position:0%
examples there the top one is a assembly
call<00:02:47.720><c> in</c><00:02:47.959><c> functional</c><00:02:50.019><c> representation</c><00:02:51.019><c> so</c>

00:02:51.849 --> 00:02:51.859 align:start position:0%
call in functional representation so
 

00:02:51.859 --> 00:02:54.699 align:start position:0%
call in functional representation so
functional<00:02:52.310><c> inline</c><00:02:52.609><c> assembly</c><00:02:53.060><c> and</c><00:02:53.659><c> there</c><00:02:54.590><c> you</c>

00:02:54.699 --> 00:02:54.709 align:start position:0%
functional inline assembly and there you
 

00:02:54.709 --> 00:02:57.550 align:start position:0%
functional inline assembly and there you
see<00:02:54.950><c> four</c><00:02:55.340><c> variables</c><00:02:55.879><c> in</c><00:02:56.090><c> the</c><00:02:56.209><c> call</c><00:02:56.420><c> that</c><00:02:57.409><c> is</c>

00:02:57.550 --> 00:02:57.560 align:start position:0%
see four variables in the call that is
 

00:02:57.560 --> 00:03:00.670 align:start position:0%
see four variables in the call that is
quite<00:02:57.799><c> readable</c><00:02:58.150><c> in</c><00:02:59.150><c> the</c><00:02:59.329><c> bottom</c><00:02:59.629><c> there</c><00:03:00.500><c> is</c>

00:03:00.670 --> 00:03:00.680 align:start position:0%
quite readable in the bottom there is
 

00:03:00.680 --> 00:03:04.569 align:start position:0%
quite readable in the bottom there is
the<00:03:01.010><c> EVM</c><00:03:01.400><c> byte</c><00:03:01.639><c> code</c><00:03:01.909><c> counterpart</c><00:03:02.569><c> and</c><00:03:03.579><c> it</c>

00:03:04.569 --> 00:03:04.579 align:start position:0%
the EVM byte code counterpart and it
 

00:03:04.579 --> 00:03:06.789 align:start position:0%
the EVM byte code counterpart and it
doesn't<00:03:04.879><c> really</c><00:03:05.060><c> look</c><00:03:05.359><c> readable</c><00:03:05.840><c> the</c><00:03:06.439><c> tone</c><00:03:06.650><c> of</c>

00:03:06.789 --> 00:03:06.799 align:start position:0%
doesn't really look readable the tone of
 

00:03:06.799 --> 00:03:09.339 align:start position:0%
doesn't really look readable the tone of
swaps<00:03:07.159><c> and</c><00:03:07.370><c> dupes</c><00:03:07.609><c> the</c><00:03:08.480><c> reason</c><00:03:08.810><c> for</c><00:03:08.959><c> that</c><00:03:09.019><c> is</c>

00:03:09.339 --> 00:03:09.349 align:start position:0%
swaps and dupes the reason for that is
 

00:03:09.349 --> 00:03:13.839 align:start position:0%
swaps and dupes the reason for that is
in<00:03:09.730><c> solidity</c><00:03:10.730><c> every</c><00:03:11.569><c> variable</c><00:03:12.139><c> is</c><00:03:12.579><c> as</c><00:03:13.579><c> a</c><00:03:13.639><c> life</c>

00:03:13.839 --> 00:03:13.849 align:start position:0%
in solidity every variable is as a life
 

00:03:13.849 --> 00:03:16.479 align:start position:0%
in solidity every variable is as a life
cycle<00:03:14.090><c> of</c><00:03:14.480><c> existence</c><00:03:14.750><c> until</c><00:03:15.590><c> the</c><00:03:16.159><c> end</c><00:03:16.280><c> of</c><00:03:16.340><c> the</c>

00:03:16.479 --> 00:03:16.489 align:start position:0%
cycle of existence until the end of the
 

00:03:16.489 --> 00:03:19.330 align:start position:0%
cycle of existence until the end of the
block<00:03:16.689><c> so</c><00:03:17.689><c> in</c><00:03:17.780><c> that</c><00:03:17.900><c> case</c><00:03:18.170><c> there</c><00:03:18.470><c> they</c><00:03:19.129><c> still</c>

00:03:19.330 --> 00:03:19.340 align:start position:0%
block so in that case there they still
 

00:03:19.340 --> 00:03:22.030 align:start position:0%
block so in that case there they still
exist<00:03:19.790><c> after</c><00:03:20.239><c> the</c><00:03:20.510><c> call</c><00:03:20.780><c> so</c><00:03:21.500><c> they</c><00:03:21.620><c> have</c><00:03:21.859><c> to</c><00:03:21.949><c> be</c>

00:03:22.030 --> 00:03:22.040 align:start position:0%
exist after the call so they have to be
 

00:03:22.040 --> 00:03:24.400 align:start position:0%
exist after the call so they have to be
kept<00:03:22.310><c> on</c><00:03:22.459><c> the</c><00:03:22.579><c> stack</c><00:03:22.879><c> and</c><00:03:23.139><c> therefore</c><00:03:24.139><c> we</c><00:03:24.260><c> need</c>

00:03:24.400 --> 00:03:24.410 align:start position:0%
kept on the stack and therefore we need
 

00:03:24.410 --> 00:03:26.259 align:start position:0%
kept on the stack and therefore we need
to<00:03:24.440><c> swap</c><00:03:24.739><c> them</c><00:03:24.919><c> around</c><00:03:25.030><c> ability</c><00:03:26.030><c> to</c><00:03:26.150><c> make</c>

00:03:26.259 --> 00:03:26.269 align:start position:0%
to swap them around ability to make
 

00:03:26.269 --> 00:03:28.990 align:start position:0%
to swap them around ability to make
duplications<00:03:26.900><c> of</c><00:03:27.079><c> them</c><00:03:27.260><c> I</c><00:03:27.730><c> guess</c><00:03:28.730><c> you</c><00:03:28.849><c> can</c>

00:03:28.990 --> 00:03:29.000 align:start position:0%
duplications of them I guess you can
 

00:03:29.000 --> 00:03:30.640 align:start position:0%
duplications of them I guess you can
agree<00:03:29.150><c> that</c><00:03:29.269><c> it's</c><00:03:29.540><c> quite</c><00:03:29.720><c> hard</c><00:03:29.750><c> to</c><00:03:30.530><c> verify</c>

00:03:30.640 --> 00:03:30.650 align:start position:0%
agree that it's quite hard to verify
 

00:03:30.650 --> 00:03:34.210 align:start position:0%
agree that it's quite hard to verify
that<00:03:31.400><c> even</c><00:03:31.669><c> byte</c><00:03:31.909><c> code</c><00:03:32.500><c> actually</c><00:03:33.500><c> corresponds</c>

00:03:34.210 --> 00:03:34.220 align:start position:0%
that even byte code actually corresponds
 

00:03:34.220 --> 00:03:38.589 align:start position:0%
that even byte code actually corresponds
to<00:03:34.310><c> that</c><00:03:34.489><c> assembly</c><00:03:36.790><c> and</c><00:03:37.790><c> these</c><00:03:37.970><c> are</c><00:03:38.150><c> this</c><00:03:38.449><c> is</c>

00:03:38.589 --> 00:03:38.599 align:start position:0%
to that assembly and these are this is
 

00:03:38.599 --> 00:03:42.339 align:start position:0%
to that assembly and these are this is
one<00:03:38.750><c> example</c><00:03:38.870><c> for</c><00:03:39.290><c> helpers</c><00:03:40.840><c> this</c><00:03:41.840><c> actually</c><00:03:42.230><c> is</c>

00:03:42.339 --> 00:03:42.349 align:start position:0%
one example for helpers this actually is
 

00:03:42.349 --> 00:03:47.009 align:start position:0%
one example for helpers this actually is
the<00:03:42.709><c> code</c><00:03:43.310><c> for</c><00:03:44.109><c> pushing</c><00:03:45.109><c> a</c><00:03:45.229><c> value</c><00:03:45.530><c> to</c><00:03:45.709><c> an</c><00:03:45.769><c> array</c>

00:03:47.009 --> 00:03:47.019 align:start position:0%
the code for pushing a value to an array
 

00:03:47.019 --> 00:03:49.869 align:start position:0%
the code for pushing a value to an array
first<00:03:48.019><c> we</c><00:03:48.199><c> retrieve</c><00:03:48.620><c> the</c><00:03:48.739><c> length</c><00:03:48.949><c> we</c><00:03:49.489><c> increase</c>

00:03:49.869 --> 00:03:49.879 align:start position:0%
first we retrieve the length we increase
 

00:03:49.879 --> 00:03:52.149 align:start position:0%
first we retrieve the length we increase
the<00:03:50.060><c> length</c><00:03:50.209><c> of</c><00:03:50.419><c> the</c><00:03:50.540><c> array</c><00:03:50.750><c> we</c><00:03:51.440><c> resize</c><00:03:51.859><c> it</c>

00:03:52.149 --> 00:03:52.159 align:start position:0%
the length of the array we resize it
 

00:03:52.159 --> 00:03:55.300 align:start position:0%
the length of the array we resize it
then<00:03:53.150><c> we</c><00:03:53.389><c> get</c><00:03:53.629><c> to</c><00:03:53.780><c> reference</c><00:03:54.260><c> in</c><00:03:54.620><c> this</c><00:03:54.979><c> example</c>

00:03:55.300 --> 00:03:55.310 align:start position:0%
then we get to reference in this example
 

00:03:55.310 --> 00:03:57.879 align:start position:0%
then we get to reference in this example
we<00:03:55.489><c> get</c><00:03:55.579><c> to</c><00:03:55.729><c> reference</c><00:03:56.180><c> of</c><00:03:56.419><c> a</c><00:03:56.870><c> storage</c><00:03:57.560><c> slot</c>

00:03:57.879 --> 00:03:57.889 align:start position:0%
we get to reference of a storage slot
 

00:03:57.889 --> 00:04:00.879 align:start position:0%
we get to reference of a storage slot
and<00:03:58.250><c> a</c><00:03:58.790><c> storage</c><00:03:58.970><c> offset</c><00:03:59.449><c> and</c><00:04:00.169><c> then</c><00:04:00.319><c> finally</c><00:04:00.769><c> we</c>

00:04:00.879 --> 00:04:00.889 align:start position:0%
and a storage offset and then finally we
 

00:04:00.889 --> 00:04:05.559 align:start position:0%
and a storage offset and then finally we
can<00:04:01.040><c> interact</c><00:04:01.629><c> with</c><00:04:02.629><c> that</c><00:04:02.720><c> array</c><00:04:04.299><c> so</c><00:04:05.299><c> there</c>

00:04:05.559 --> 00:04:05.569 align:start position:0%
can interact with that array so there
 

00:04:05.569 --> 00:04:09.099 align:start position:0%
can interact with that array so there
must<00:04:05.750><c> be</c><00:04:05.930><c> a</c><00:04:05.959><c> way</c><00:04:06.169><c> to</c><00:04:06.229><c> improve</c><00:04:06.859><c> this</c><00:04:08.049><c> let's</c><00:04:09.049><c> just</c>

00:04:09.099 --> 00:04:09.109 align:start position:0%
must be a way to improve this let's just
 

00:04:09.109 --> 00:04:10.869 align:start position:0%
must be a way to improve this let's just
take<00:04:09.319><c> a</c><00:04:09.349><c> step</c><00:04:09.470><c> back</c><00:04:09.829><c> and</c><00:04:10.159><c> look</c><00:04:10.669><c> at</c><00:04:10.790><c> other</c>

00:04:10.869 --> 00:04:10.879 align:start position:0%
take a step back and look at other
 

00:04:10.879 --> 00:04:13.330 align:start position:0%
take a step back and look at other
compilers<00:04:11.530><c> you</c><00:04:12.530><c> know</c><00:04:12.650><c> outside</c><00:04:12.829><c> of</c><00:04:13.099><c> the</c>

00:04:13.330 --> 00:04:13.340 align:start position:0%
compilers you know outside of the
 

00:04:13.340 --> 00:04:18.300 align:start position:0%
compilers you know outside of the
etherium<00:04:14.739><c> so</c><00:04:15.739><c> basically</c><00:04:16.070><c> for</c><00:04:16.820><c> many</c><00:04:17.389><c> years</c>

00:04:18.300 --> 00:04:18.310 align:start position:0%
etherium so basically for many years
 

00:04:18.310 --> 00:04:21.099 align:start position:0%
etherium so basically for many years
compilers<00:04:19.310><c> traditional</c><00:04:20.090><c> compilers</c><00:04:20.539><c> have</c>

00:04:21.099 --> 00:04:21.109 align:start position:0%
compilers traditional compilers have
 

00:04:21.109 --> 00:04:23.230 align:start position:0%
compilers traditional compilers have
been<00:04:21.260><c> working</c><00:04:21.650><c> in</c><00:04:21.739><c> different</c><00:04:22.039><c> stages</c><00:04:22.280><c> the</c>

00:04:23.230 --> 00:04:23.240 align:start position:0%
been working in different stages the
 

00:04:23.240 --> 00:04:25.029 align:start position:0%
been working in different stages the
first<00:04:23.270><c> stage</c><00:04:23.539><c> is</c><00:04:23.900><c> the</c><00:04:24.020><c> front</c><00:04:24.260><c> end</c><00:04:24.500><c> which</c>

00:04:25.029 --> 00:04:25.039 align:start position:0%
first stage is the front end which
 

00:04:25.039 --> 00:04:27.580 align:start position:0%
first stage is the front end which
parses<00:04:25.279><c> the</c><00:04:25.550><c> source</c><00:04:25.760><c> code</c><00:04:26.060><c> does</c>

00:04:27.580 --> 00:04:27.590 align:start position:0%
parses the source code does
 

00:04:27.590 --> 00:04:29.920 align:start position:0%
parses the source code does
let's<00:04:28.010><c> check</c><00:04:28.190><c> several</c><00:04:28.430><c> things</c><00:04:28.790><c> and</c><00:04:29.120><c> finally</c>

00:04:29.920 --> 00:04:29.930 align:start position:0%
let's check several things and finally
 

00:04:29.930 --> 00:04:31.810 align:start position:0%
let's check several things and finally
creates<00:04:30.800><c> an</c><00:04:30.919><c> intermediate</c><00:04:31.460><c> representation</c>

00:04:31.810 --> 00:04:31.820 align:start position:0%
creates an intermediate representation
 

00:04:31.820 --> 00:04:35.770 align:start position:0%
creates an intermediate representation
of<00:04:32.360><c> the</c><00:04:33.320><c> program</c><00:04:34.090><c> the</c><00:04:35.090><c> next</c><00:04:35.270><c> stage</c><00:04:35.540><c> is</c><00:04:35.750><c> the</c>

00:04:35.770 --> 00:04:35.780 align:start position:0%
of the program the next stage is the
 

00:04:35.780 --> 00:04:37.530 align:start position:0%
of the program the next stage is the
middle<00:04:36.110><c> end</c><00:04:36.260><c> which</c><00:04:36.889><c> can</c><00:04:36.919><c> apply</c><00:04:37.340><c> different</c>

00:04:37.530 --> 00:04:37.540 align:start position:0%
middle end which can apply different
 

00:04:37.540 --> 00:04:40.180 align:start position:0%
middle end which can apply different
optimizations<00:04:38.540><c> on</c><00:04:38.780><c> the</c><00:04:39.080><c> front</c><00:04:39.290><c> on</c><00:04:39.800><c> the</c>

00:04:40.180 --> 00:04:40.190 align:start position:0%
optimizations on the front on the
 

00:04:40.190 --> 00:04:43.210 align:start position:0%
optimizations on the front on the
intermediate<00:04:41.000><c> representation</c><00:04:41.830><c> and</c><00:04:42.830><c> the</c><00:04:43.100><c> last</c>

00:04:43.210 --> 00:04:43.220 align:start position:0%
intermediate representation and the last
 

00:04:43.220 --> 00:04:45.129 align:start position:0%
intermediate representation and the last
one<00:04:43.340><c> is</c><00:04:43.430><c> the</c><00:04:43.550><c> back</c><00:04:43.699><c> end</c><00:04:43.940><c> of</c><00:04:44.060><c> course</c><00:04:44.570><c> which</c>

00:04:45.129 --> 00:04:45.139 align:start position:0%
one is the back end of course which
 

00:04:45.139 --> 00:04:47.530 align:start position:0%
one is the back end of course which
generates<00:04:46.130><c> bytecode</c><00:04:46.639><c> for</c><00:04:47.180><c> the</c><00:04:47.270><c> target</c>

00:04:47.530 --> 00:04:47.540 align:start position:0%
generates bytecode for the target
 

00:04:47.540 --> 00:04:49.450 align:start position:0%
generates bytecode for the target
machine<00:04:47.690><c> and</c><00:04:48.110><c> again</c><00:04:48.770><c> it</c><00:04:49.100><c> can</c><00:04:49.280><c> do</c>

00:04:49.450 --> 00:04:49.460 align:start position:0%
machine and again it can do
 

00:04:49.460 --> 00:04:52.800 align:start position:0%
machine and again it can do
optimizations<00:04:50.090><c> there</c><00:04:51.340><c> compared</c><00:04:52.340><c> to</c><00:04:52.460><c> debt</c>

00:04:52.800 --> 00:04:52.810 align:start position:0%
optimizations there compared to debt
 

00:04:52.810 --> 00:04:55.510 align:start position:0%
optimizations there compared to debt
solidity<00:04:53.810><c> only</c><00:04:54.080><c> has</c><00:04:54.199><c> two</c><00:04:54.410><c> stages</c><00:04:54.680><c> were</c><00:04:55.340><c> more</c>

00:04:55.510 --> 00:04:55.520 align:start position:0%
solidity only has two stages were more
 

00:04:55.520 --> 00:04:58.480 align:start position:0%
solidity only has two stages were more
like<00:04:55.699><c> 1.5</c><00:04:55.970><c> stages</c><00:04:56.960><c> there's</c><00:04:57.889><c> one</c><00:04:58.040><c> stage</c><00:04:58.280><c> which</c>

00:04:58.480 --> 00:04:58.490 align:start position:0%
like 1.5 stages there's one stage which
 

00:04:58.490 --> 00:05:00.909 align:start position:0%
like 1.5 stages there's one stage which
does<00:04:58.729><c> everything</c><00:04:58.900><c> and</c><00:04:59.900><c> there's</c><00:05:00.500><c> another</c><00:05:00.680><c> one</c>

00:05:00.909 --> 00:05:00.919 align:start position:0%
does everything and there's another one
 

00:05:00.919 --> 00:05:03.400 align:start position:0%
does everything and there's another one
which<00:05:01.130><c> optimizes</c><00:05:01.310><c> evm</c><00:05:01.970><c> bytecode</c><00:05:02.419><c> at</c><00:05:03.229><c> this</c>

00:05:03.400 --> 00:05:03.410 align:start position:0%
which optimizes evm bytecode at this
 

00:05:03.410 --> 00:05:06.310 align:start position:0%
which optimizes evm bytecode at this
stage<00:05:03.620><c> has</c><00:05:03.889><c> no</c><00:05:04.100><c> idea</c><00:05:04.720><c> what</c><00:05:05.720><c> the</c><00:05:05.840><c> source</c><00:05:06.080><c> code</c>

00:05:06.310 --> 00:05:06.320 align:start position:0%
stage has no idea what the source code
 

00:05:06.320 --> 00:05:10.060 align:start position:0%
stage has no idea what the source code
was<00:05:07.930><c> now</c><00:05:08.930><c> introducing</c><00:05:09.500><c> an</c><00:05:09.620><c> intermediate</c>

00:05:10.060 --> 00:05:10.070 align:start position:0%
was now introducing an intermediate
 

00:05:10.070 --> 00:05:14.230 align:start position:0%
was now introducing an intermediate
language<00:05:10.220><c> we'll</c><00:05:10.610><c> change</c><00:05:10.940><c> it</c><00:05:11.180><c> to</c><00:05:11.540><c> or</c><00:05:12.470><c> till</c><00:05:13.240><c> all</c>

00:05:14.230 --> 00:05:14.240 align:start position:0%
language we'll change it to or till all
 

00:05:14.240 --> 00:05:17.110 align:start position:0%
language we'll change it to or till all
the<00:05:14.360><c> other</c><00:05:14.450><c> compilers</c><00:05:14.780><c> work</c><00:05:15.430><c> however</c><00:05:16.430><c> there</c>

00:05:17.110 --> 00:05:17.120 align:start position:0%
the other compilers work however there
 

00:05:17.120 --> 00:05:19.960 align:start position:0%
the other compilers work however there
is<00:05:17.330><c> a</c><00:05:17.360><c> big</c><00:05:17.930><c> difference</c><00:05:18.490><c> because</c><00:05:19.490><c> the</c><00:05:19.580><c> reason</c>

00:05:19.960 --> 00:05:19.970 align:start position:0%
is a big difference because the reason
 

00:05:19.970 --> 00:05:22.510 align:start position:0%
is a big difference because the reason
most<00:05:20.180><c> compilers</c><00:05:20.479><c> work</c><00:05:20.930><c> that</c><00:05:21.139><c> way</c><00:05:21.380><c> is</c><00:05:21.620><c> they</c>

00:05:22.510 --> 00:05:22.520 align:start position:0%
most compilers work that way is they
 

00:05:22.520 --> 00:05:25.029 align:start position:0%
most compilers work that way is they
target<00:05:22.940><c> multiple</c><00:05:23.090><c> machines</c><00:05:23.710><c> so</c><00:05:24.710><c> if</c><00:05:24.800><c> you</c><00:05:24.889><c> look</c>

00:05:25.029 --> 00:05:25.039 align:start position:0%
target multiple machines so if you look
 

00:05:25.039 --> 00:05:28.900 align:start position:0%
target multiple machines so if you look
at<00:05:25.130><c> GCC</c><00:05:25.610><c> or</c><00:05:25.850><c> LLVM</c><00:05:26.419><c> they</c><00:05:27.139><c> support</c><00:05:27.620><c> a</c><00:05:27.800><c> like</c><00:05:28.430><c> C</c><00:05:28.669><c> and</c>

00:05:28.900 --> 00:05:28.910 align:start position:0%
at GCC or LLVM they support a like C and
 

00:05:28.910 --> 00:05:31.510 align:start position:0%
at GCC or LLVM they support a like C and
you<00:05:29.720><c> can</c><00:05:29.870><c> compile</c><00:05:30.199><c> the</c><00:05:30.289><c> same</c><00:05:30.440><c> C</c><00:05:30.710><c> code</c><00:05:31.160><c> to</c>

00:05:31.510 --> 00:05:31.520 align:start position:0%
you can compile the same C code to
 

00:05:31.520 --> 00:05:34.840 align:start position:0%
you can compile the same C code to
multiple<00:05:31.970><c> computers</c><00:05:32.479><c> and</c><00:05:33.250><c> with</c><00:05:34.250><c> compiler</c>

00:05:34.840 --> 00:05:34.850 align:start position:0%
multiple computers and with compiler
 

00:05:34.850 --> 00:05:37.180 align:start position:0%
multiple computers and with compiler
toolkits<00:05:35.360><c> they</c><00:05:35.900><c> also</c><00:05:36.110><c> support</c><00:05:36.979><c> multiple</c>

00:05:37.180 --> 00:05:37.190 align:start position:0%
toolkits they also support multiple
 

00:05:37.190 --> 00:05:39.909 align:start position:0%
toolkits they also support multiple
languages<00:05:37.700><c> on</c><00:05:37.850><c> the</c><00:05:37.880><c> input</c><00:05:38.210><c> side</c><00:05:38.500><c> and</c><00:05:39.500><c> they</c><00:05:39.680><c> can</c>

00:05:39.909 --> 00:05:39.919 align:start position:0%
languages on the input side and they can
 

00:05:39.919 --> 00:05:42.670 align:start position:0%
languages on the input side and they can
utilize<00:05:40.340><c> the</c><00:05:40.550><c> same</c><00:05:40.580><c> back-end</c><00:05:41.240><c> written</c><00:05:41.680><c> of</c>

00:05:42.670 --> 00:05:42.680 align:start position:0%
utilize the same back-end written of
 

00:05:42.680 --> 00:05:45.190 align:start position:0%
utilize the same back-end written of
course<00:05:42.770><c> this</c><00:05:43.160><c> applies</c><00:05:43.490><c> to</c><00:05:43.520><c> solidity</c><00:05:44.120><c> but</c><00:05:45.080><c> the</c>

00:05:45.190 --> 00:05:45.200 align:start position:0%
course this applies to solidity but the
 

00:05:45.200 --> 00:05:47.589 align:start position:0%
course this applies to solidity but the
main<00:05:45.380><c> reason</c><00:05:45.970><c> this</c><00:05:46.970><c> makes</c><00:05:47.210><c> sense</c><00:05:47.389><c> for</c>

00:05:47.589 --> 00:05:47.599 align:start position:0%
main reason this makes sense for
 

00:05:47.599 --> 00:05:50.980 align:start position:0%
main reason this makes sense for
solidity<00:05:48.020><c> is</c><00:05:48.310><c> verification</c><00:05:49.310><c> of</c><00:05:49.940><c> what</c><00:05:50.570><c> happens</c>

00:05:50.980 --> 00:05:50.990 align:start position:0%
solidity is verification of what happens
 

00:05:50.990 --> 00:05:54.460 align:start position:0%
solidity is verification of what happens
within<00:05:51.229><c> the</c><00:05:51.320><c> compiler</c><00:05:53.050><c> well</c><00:05:54.050><c> actually</c><00:05:54.169><c> I</c><00:05:54.380><c> just</c>

00:05:54.460 --> 00:05:54.470 align:start position:0%
within the compiler well actually I just
 

00:05:54.470 --> 00:05:58.120 align:start position:0%
within the compiler well actually I just
said<00:05:54.770><c> these</c><00:05:54.950><c> there</c><00:05:55.340><c> and</c><00:05:56.349><c> yeah</c><00:05:57.349><c> like</c><00:05:57.620><c> the</c><00:05:57.770><c> last</c>

00:05:58.120 --> 00:05:58.130 align:start position:0%
said these there and yeah like the last
 

00:05:58.130 --> 00:06:01.180 align:start position:0%
said these there and yeah like the last
point<00:05:58.340><c> in</c><00:05:58.550><c> your</c><00:05:58.639><c> bytecode</c><00:05:59.210><c> and</c><00:05:59.979><c> since</c><00:06:00.979><c> this</c>

00:06:01.180 --> 00:06:01.190 align:start position:0%
point in your bytecode and since this
 

00:06:01.190 --> 00:06:02.860 align:start position:0%
point in your bytecode and since this
intermediate<00:06:01.789><c> representation</c><00:06:02.660><c> this</c>

00:06:02.860 --> 00:06:02.870 align:start position:0%
intermediate representation this
 

00:06:02.870 --> 00:06:06.129 align:start position:0%
intermediate representation this
language<00:06:03.310><c> by</c><00:06:04.310><c> definition</c><00:06:04.639><c> has</c><00:06:05.030><c> to</c><00:06:05.060><c> be</c><00:06:05.360><c> a</c><00:06:05.630><c> much</c>

00:06:06.129 --> 00:06:06.139 align:start position:0%
language by definition has to be a much
 

00:06:06.139 --> 00:06:08.560 align:start position:0%
language by definition has to be a much
simpler<00:06:06.620><c> language</c><00:06:06.800><c> than</c><00:06:07.610><c> solidity</c><00:06:08.060><c> is</c><00:06:08.300><c> and</c>

00:06:08.560 --> 00:06:08.570 align:start position:0%
simpler language than solidity is and
 

00:06:08.570 --> 00:06:10.510 align:start position:0%
simpler language than solidity is and
that<00:06:09.080><c> of</c><00:06:09.200><c> course</c><00:06:09.229><c> means</c><00:06:09.620><c> the</c><00:06:10.310><c> bytecode</c>

00:06:10.510 --> 00:06:10.520 align:start position:0%
that of course means the bytecode
 

00:06:10.520 --> 00:06:12.760 align:start position:0%
that of course means the bytecode
generation<00:06:11.270><c> of</c><00:06:11.479><c> it</c><00:06:11.720><c> should</c><00:06:12.200><c> be</c><00:06:12.349><c> much</c><00:06:12.560><c> more</c>

00:06:12.760 --> 00:06:12.770 align:start position:0%
generation of it should be much more
 

00:06:12.770 --> 00:06:16.420 align:start position:0%
generation of it should be much more
simple<00:06:13.010><c> so</c><00:06:14.650><c> what</c><00:06:15.650><c> does</c><00:06:15.800><c> the</c><00:06:15.889><c> language</c><00:06:16.039><c> look</c>

00:06:16.420 --> 00:06:16.430 align:start position:0%
simple so what does the language look
 

00:06:16.430 --> 00:06:20.500 align:start position:0%
simple so what does the language look
like<00:06:17.470><c> here's</c><00:06:18.470><c> a</c><00:06:18.560><c> simple</c><00:06:18.860><c> contract</c><00:06:19.270><c> it</c><00:06:20.270><c> just</c>

00:06:20.500 --> 00:06:20.510 align:start position:0%
like here's a simple contract it just
 

00:06:20.510 --> 00:06:23.860 align:start position:0%
like here's a simple contract it just
returns<00:06:20.810><c> a</c><00:06:21.139><c> string</c><00:06:21.340><c> and</c><00:06:22.360><c> this</c><00:06:23.360><c> is</c><00:06:23.630><c> an</c>

00:06:23.860 --> 00:06:23.870 align:start position:0%
returns a string and this is an
 

00:06:23.870 --> 00:06:26.740 align:start position:0%
returns a string and this is an
incomplete<00:06:24.139><c> example</c><00:06:24.860><c> of</c><00:06:25.039><c> that</c><00:06:26.000><c> contract</c><00:06:26.510><c> in</c>

00:06:26.740 --> 00:06:26.750 align:start position:0%
incomplete example of that contract in
 

00:06:26.750 --> 00:06:29.529 align:start position:0%
incomplete example of that contract in
julia<00:06:27.260><c> the</c><00:06:27.789><c> important</c><00:06:28.789><c> part</c><00:06:29.000><c> is</c><00:06:29.210><c> the</c><00:06:29.389><c> one</c>

00:06:29.529 --> 00:06:29.539 align:start position:0%
julia the important part is the one
 

00:06:29.539 --> 00:06:32.050 align:start position:0%
julia the important part is the one
highlighted<00:06:30.139><c> on</c><00:06:30.260><c> the</c><00:06:30.380><c> top</c><00:06:30.560><c> so</c><00:06:31.310><c> you</c><00:06:31.340><c> create</c><00:06:31.789><c> the</c>

00:06:32.050 --> 00:06:32.060 align:start position:0%
highlighted on the top so you create the
 

00:06:32.060 --> 00:06:35.469 align:start position:0%
highlighted on the top so you create the
if<00:06:33.050><c> you</c><00:06:33.169><c> look</c><00:06:33.260><c> at</c><00:06:33.380><c> the</c><00:06:33.470><c> string</c><00:06:33.970><c> that</c><00:06:34.970><c> string</c><00:06:35.300><c> is</c>

00:06:35.469 --> 00:06:35.479 align:start position:0%
if you look at the string that string is
 

00:06:35.479 --> 00:06:39.130 align:start position:0%
if you look at the string that string is
encoded<00:06:35.960><c> there</c><00:06:36.200><c> in</c><00:06:36.979><c> hexadecimal</c><00:06:37.960><c> it</c><00:06:38.960><c> is</c>

00:06:39.130 --> 00:06:39.140 align:start position:0%
encoded there in hexadecimal it is
 

00:06:39.140 --> 00:06:41.559 align:start position:0%
encoded there in hexadecimal it is
assigned<00:06:39.380><c> to</c><00:06:39.530><c> a</c><00:06:39.620><c> variable</c><00:06:39.770><c> it</c><00:06:40.250><c> is</c><00:06:40.640><c> ABI</c><00:06:41.060><c> encode</c>

00:06:41.559 --> 00:06:41.569 align:start position:0%
assigned to a variable it is ABI encode
 

00:06:41.569 --> 00:06:43.980 align:start position:0%
assigned to a variable it is ABI encode
into<00:06:41.869><c> memory</c><00:06:42.169><c> and</c><00:06:42.469><c> death</c><00:06:42.949><c> memories</c><00:06:43.339><c> return</c>

00:06:43.980 --> 00:06:43.990 align:start position:0%
into memory and death memories return
 

00:06:43.990 --> 00:06:46.809 align:start position:0%
into memory and death memories return
the<00:06:44.990><c> part</c><00:06:45.229><c> in</c><00:06:45.349><c> the</c><00:06:45.439><c> bottom</c><00:06:45.740><c> is</c><00:06:46.009><c> you</c><00:06:46.729><c> know</c>

00:06:46.809 --> 00:06:46.819 align:start position:0%
the part in the bottom is you know
 

00:06:46.819 --> 00:06:50.079 align:start position:0%
the part in the bottom is you know
helper<00:06:47.419><c> a</c><00:06:47.629><c> compiler</c><00:06:48.589><c> real</c><00:06:48.889><c> output</c><00:06:49.189><c> into</c><00:06:49.969><c> the</c>

00:06:50.079 --> 00:06:50.089 align:start position:0%
helper a compiler real output into the
 

00:06:50.089 --> 00:06:52.839 align:start position:0%
helper a compiler real output into the
contracts<00:06:50.569><c> what</c><00:06:51.169><c> it</c><00:06:51.289><c> helper</c><00:06:51.649><c> does</c><00:06:51.830><c> is</c><00:06:52.069><c> it</c>

00:06:52.839 --> 00:06:52.849 align:start position:0%
contracts what it helper does is it
 

00:06:52.849 --> 00:06:55.779 align:start position:0%
contracts what it helper does is it
receives<00:06:53.800><c> control</c><00:06:54.800><c> when</c><00:06:55.249><c> the</c><00:06:55.339><c> contract</c><00:06:55.699><c> is</c>

00:06:55.779 --> 00:06:55.789 align:start position:0%
receives control when the contract is
 

00:06:55.789 --> 00:06:58.089 align:start position:0%
receives control when the contract is
called<00:06:55.999><c> and</c><00:06:56.719><c> it</c><00:06:56.839><c> decides</c><00:06:57.229><c> which</c><00:06:57.469><c> function</c>

00:06:58.089 --> 00:06:58.099 align:start position:0%
called and it decides which function
 

00:06:58.099 --> 00:07:00.489 align:start position:0%
called and it decides which function
within<00:06:59.059><c> the</c><00:06:59.179><c> contract</c><00:06:59.629><c> should</c><00:06:59.779><c> be</c><00:06:59.839><c> executed</c>

00:07:00.489 --> 00:07:00.499 align:start position:0%
within the contract should be executed
 

00:07:00.499 --> 00:07:03.369 align:start position:0%
within the contract should be executed
or<00:07:00.849><c> in</c><00:07:01.849><c> the</c><00:07:01.939><c> case</c><00:07:02.149><c> none</c><00:07:02.330><c> of</c><00:07:02.360><c> the</c><00:07:02.449><c> match</c><00:07:02.779><c> it</c><00:07:03.199><c> just</c>

00:07:03.369 --> 00:07:03.379 align:start position:0%
or in the case none of the match it just
 

00:07:03.379 --> 00:07:04.929 align:start position:0%
or in the case none of the match it just
ensures<00:07:03.529><c> that</c><00:07:03.740><c> the</c><00:07:04.189><c> contract</c><00:07:04.610><c> hasn't</c>

00:07:04.929 --> 00:07:04.939 align:start position:0%
ensures that the contract hasn't
 

00:07:04.939 --> 00:07:09.100 align:start position:0%
ensures that the contract hasn't
received<00:07:05.300><c> any</c><00:07:05.599><c> money</c><00:07:06.939><c> and</c><00:07:07.939><c> you</c><00:07:08.629><c> can</c><00:07:08.749><c> extend</c>

00:07:09.100 --> 00:07:09.110 align:start position:0%
received any money and you can extend
 

00:07:09.110 --> 00:07:11.379 align:start position:0%
received any money and you can extend
this<00:07:09.349><c> with</c><00:07:09.860><c> the</c><00:07:09.979><c> missing</c><00:07:10.249><c> parts</c><00:07:10.580><c> because</c><00:07:11.240><c> you</c>

00:07:11.379 --> 00:07:11.389 align:start position:0%
this with the missing parts because you
 

00:07:11.389 --> 00:07:14.279 align:start position:0%
this with the missing parts because you
see<00:07:11.629><c> there's</c><00:07:12.439><c> an</c><00:07:12.529><c> ABI</c><00:07:12.919><c> in</c><00:07:13.279><c> code</c><00:07:13.520><c> string</c><00:07:13.939><c> and</c>

00:07:14.279 --> 00:07:14.289 align:start position:0%
see there's an ABI in code string and
 

00:07:14.289 --> 00:07:17.769 align:start position:0%
see there's an ABI in code string and
sure<00:07:15.289><c> nowhere</c><00:07:15.860><c> you</c><00:07:16.009><c> transfer</c><00:07:16.629><c> extract</c><00:07:17.629><c> code</c>

00:07:17.769 --> 00:07:17.779 align:start position:0%
sure nowhere you transfer extract code
 

00:07:17.779 --> 00:07:21.609 align:start position:0%
sure nowhere you transfer extract code
signature<00:07:18.080><c> so</c><00:07:18.919><c> these</c><00:07:19.039><c> are</c><00:07:19.279><c> in</c><00:07:19.999><c> this</c><00:07:20.149><c> slide</c><00:07:20.619><c> of</c>

00:07:21.609 --> 00:07:21.619 align:start position:0%
signature so these are in this slide of
 

00:07:21.619 --> 00:07:23.230 align:start position:0%
signature so these are in this slide of
course<00:07:21.919><c> not</c><00:07:22.339><c> all</c><00:07:22.369><c> of</c><00:07:22.550><c> them</c><00:07:22.669><c> are</c><00:07:22.729><c> implemented</c>

00:07:23.230 --> 00:07:23.240 align:start position:0%
course not all of them are implemented
 

00:07:23.240 --> 00:07:25.299 align:start position:0%
course not all of them are implemented
and<00:07:23.529><c> but</c><00:07:24.529><c> you</c><00:07:24.589><c> can</c><00:07:24.740><c> see</c><00:07:24.860><c> they</c><00:07:25.009><c> are</c><00:07:25.039><c> fairly</c>

00:07:25.299 --> 00:07:25.309 align:start position:0%
and but you can see they are fairly
 

00:07:25.309 --> 00:07:28.059 align:start position:0%
and but you can see they are fairly
simple<00:07:25.669><c> these</c><00:07:26.149><c> are</c><00:07:26.180><c> all</c><00:07:26.449><c> helpers</c><00:07:26.990><c> which</c><00:07:27.830><c> will</c>

00:07:28.059 --> 00:07:28.069 align:start position:0%
simple these are all helpers which will
 

00:07:28.069 --> 00:07:30.790 align:start position:0%
simple these are all helpers which will
be<00:07:28.249><c> I</c><00:07:28.459><c> put</c><00:07:28.789><c> it</c><00:07:28.939><c> into</c><00:07:29.509><c> each</c><00:07:30.139><c> of</c><00:07:30.319><c> the</c><00:07:30.409><c> contracts</c>

00:07:30.790 --> 00:07:30.800 align:start position:0%
be I put it into each of the contracts
 

00:07:30.800 --> 00:07:32.679 align:start position:0%
be I put it into each of the contracts
and<00:07:30.889><c> that</c><00:07:31.069><c> happens</c><00:07:31.459><c> already</c><00:07:31.759><c> but</c><00:07:32.330><c> all</c><00:07:32.449><c> of</c><00:07:32.569><c> this</c>

00:07:32.679 --> 00:07:32.689 align:start position:0%
and that happens already but all of this
 

00:07:32.689 --> 00:07:35.139 align:start position:0%
and that happens already but all of this
is<00:07:32.749><c> written</c><00:07:33.110><c> in</c><00:07:33.289><c> C++</c><00:07:33.830><c> and</c><00:07:34.009><c> is</c><00:07:34.490><c> hidden</c><00:07:34.789><c> from</c><00:07:34.969><c> the</c>

00:07:35.139 --> 00:07:35.149 align:start position:0%
is written in C++ and is hidden from the
 

00:07:35.149 --> 00:07:39.129 align:start position:0%
is written in C++ and is hidden from the
eye<00:07:36.099><c> there</c><00:07:37.099><c> is</c><00:07:37.189><c> one</c><00:07:37.430><c> thing</c><00:07:37.729><c> which</c><00:07:37.999><c> one</c><00:07:38.809><c> can</c>

00:07:39.129 --> 00:07:39.139 align:start position:0%
eye there is one thing which one can
 

00:07:39.139 --> 00:07:42.609 align:start position:0%
eye there is one thing which one can
notice<00:07:39.919><c> here</c><00:07:40.539><c> extra</c><00:07:41.539><c> code</c><00:07:41.719><c> signature</c><00:07:42.080><c> is</c><00:07:42.409><c> a</c>

00:07:42.609 --> 00:07:42.619 align:start position:0%
notice here extra code signature is a
 

00:07:42.619 --> 00:07:45.579 align:start position:0%
notice here extra code signature is a
one-liner<00:07:43.419><c> that's</c><00:07:44.419><c> why</c><00:07:44.629><c> optimizations</c><00:07:45.349><c> make</c>

00:07:45.579 --> 00:07:45.589 align:start position:0%
one-liner that's why optimizations make
 

00:07:45.589 --> 00:07:48.549 align:start position:0%
one-liner that's why optimizations make
sense<00:07:45.919><c> this</c><00:07:46.759><c> one</c><00:07:47.029><c> should</c><00:07:47.330><c> be</c><00:07:47.360><c> inlined</c><00:07:47.930><c> it</c>

00:07:48.549 --> 00:07:48.559 align:start position:0%
sense this one should be inlined it
 

00:07:48.559 --> 00:07:50.379 align:start position:0%
sense this one should be inlined it
shouldn't<00:07:48.919><c> be</c><00:07:49.009><c> a</c><00:07:49.039><c> function</c><00:07:49.430><c> call</c><00:07:49.669><c> it</c><00:07:50.149><c> should</c>

00:07:50.379 --> 00:07:50.389 align:start position:0%
shouldn't be a function call it should
 

00:07:50.389 --> 00:07:55.719 align:start position:0%
shouldn't be a function call it should
be<00:07:50.509><c> just</c><00:07:50.860><c> those</c><00:07:51.860><c> few</c><00:07:52.279><c> instructions</c><00:07:54.729><c> now</c>

00:07:55.719 --> 00:07:55.729 align:start position:0%
be just those few instructions now
 

00:07:55.729 --> 00:07:58.589 align:start position:0%
be just those few instructions now
here's<00:07:56.119><c> the</c><00:07:56.330><c> the</c><00:07:56.599><c> helper</c><00:07:56.959><c> you</c><00:07:57.649><c> have</c><00:07:57.740><c> seen</c><00:07:57.979><c> and</c>

00:07:58.589 --> 00:07:58.599 align:start position:0%
here's the the helper you have seen and
 

00:07:58.599 --> 00:08:00.790 align:start position:0%
here's the the helper you have seen and
here's<00:07:59.599><c> a</c><00:07:59.659><c> possible</c><00:07:59.990><c> way</c><00:08:00.139><c> to</c><00:08:00.199><c> write</c><00:08:00.529><c> it</c><00:08:00.559><c> in</c>

00:08:00.790 --> 00:08:00.800 align:start position:0%
here's a possible way to write it in
 

00:08:00.800 --> 00:08:06.100 align:start position:0%
here's a possible way to write it in
julia<00:08:01.159><c> i</c><00:08:01.399><c> think</c><00:08:01.999><c> it's</c><00:08:02.089><c> much</c><00:08:02.209><c> more</c><00:08:02.269><c> readable</c><00:08:05.110><c> so</c>

00:08:06.100 --> 00:08:06.110 align:start position:0%
julia i think it's much more readable so
 

00:08:06.110 --> 00:08:08.079 align:start position:0%
julia i think it's much more readable so
you<00:08:06.740><c> know</c><00:08:06.860><c> by</c><00:08:07.009><c> moving</c><00:08:07.279><c> most</c><00:08:07.550><c> of</c><00:08:07.669><c> the</c><00:08:07.729><c> compiler</c>

00:08:08.079 --> 00:08:08.089 align:start position:0%
you know by moving most of the compiler
 

00:08:08.089 --> 00:08:10.899 align:start position:0%
you know by moving most of the compiler
into<00:08:08.360><c> julia</c><00:08:08.749><c> from</c><00:08:08.990><c> C++</c><00:08:09.369><c> gives</c><00:08:10.369><c> us</c><00:08:10.519><c> a</c><00:08:10.579><c> couple</c><00:08:10.819><c> of</c>

00:08:10.899 --> 00:08:10.909 align:start position:0%
into julia from C++ gives us a couple of
 

00:08:10.909 --> 00:08:13.230 align:start position:0%
into julia from C++ gives us a couple of
benefits<00:08:11.059><c> it</c><00:08:11.899><c> should</c><00:08:12.110><c> help</c><00:08:12.289><c> auditing</c><00:08:12.740><c> efforts</c>

00:08:13.230 --> 00:08:13.240 align:start position:0%
benefits it should help auditing efforts
 

00:08:13.240 --> 00:08:16.029 align:start position:0%
benefits it should help auditing efforts
because<00:08:14.240><c> one</c><00:08:14.749><c> can't</c><00:08:15.019><c> just</c><00:08:15.079><c> review</c><00:08:15.589><c> this</c><00:08:15.829><c> much</c>

00:08:16.029 --> 00:08:16.039 align:start position:0%
because one can't just review this much
 

00:08:16.039 --> 00:08:18.249 align:start position:0%
because one can't just review this much
more<00:08:16.219><c> simple</c><00:08:16.519><c> language</c><00:08:16.669><c> Julia</c><00:08:17.329><c> and</c><00:08:17.629><c> all</c><00:08:18.169><c> the</c>

00:08:18.249 --> 00:08:18.259 align:start position:0%
more simple language Julia and all the
 

00:08:18.259 --> 00:08:21.089 align:start position:0%
more simple language Julia and all the
helpers<00:08:18.619><c> written</c><00:08:19.099><c> in</c><00:08:19.189><c> them</c><00:08:19.339><c> as</c><00:08:19.899><c> opposed</c><00:08:20.899><c> to</c>

00:08:21.089 --> 00:08:21.099 align:start position:0%
helpers written in them as opposed to
 

00:08:21.099 --> 00:08:24.040 align:start position:0%
helpers written in them as opposed to
finding<00:08:22.099><c> someone</c><00:08:22.459><c> who</c><00:08:23.119><c> is</c><00:08:23.180><c> happy</c><00:08:23.509><c> to</c><00:08:23.659><c> review</c>

00:08:24.040 --> 00:08:24.050 align:start position:0%
finding someone who is happy to review
 

00:08:24.050 --> 00:08:29.159 align:start position:0%
finding someone who is happy to review
C++<00:08:24.740><c> I</c><00:08:25.009><c> mean</c><00:08:25.909><c> I</c><00:08:25.939><c> wouldn't</c><00:08:26.329><c> want</c><00:08:26.509><c> to</c><00:08:26.539><c> review</c><00:08:26.839><c> C++</c>

00:08:29.159 --> 00:08:29.169 align:start position:0%
C++ I mean I wouldn't want to review C++
 

00:08:29.169 --> 00:08:32.469 align:start position:0%
C++ I mean I wouldn't want to review C++
and<00:08:30.169><c> it</c><00:08:30.680><c> also</c><00:08:30.829><c> allows</c><00:08:31.249><c> a</c><00:08:31.639><c> simple</c><00:08:32.209><c> framework</c>

00:08:32.469 --> 00:08:32.479 align:start position:0%
and it also allows a simple framework
 

00:08:32.479 --> 00:08:35.110 align:start position:0%
and it also allows a simple framework
for<00:08:32.810><c> optimizations</c><00:08:33.439><c> because</c><00:08:34.250><c> basically</c><00:08:34.459><c> here</c>

00:08:35.110 --> 00:08:35.120 align:start position:0%
for optimizations because basically here
 

00:08:35.120 --> 00:08:38.409 align:start position:0%
for optimizations because basically here
you<00:08:35.149><c> will</c><00:08:35.509><c> just</c><00:08:35.889><c> optimize</c><00:08:36.889><c> julia</c><00:08:37.610><c> code</c><00:08:37.880><c> right</c>

00:08:38.409 --> 00:08:38.419 align:start position:0%
you will just optimize julia code right
 

00:08:38.419 --> 00:08:39.879 align:start position:0%
you will just optimize julia code right
now<00:08:38.449><c> if</c><00:08:38.779><c> you</c><00:08:38.899><c> want</c><00:08:39.050><c> to</c><00:08:39.110><c> optimize</c><00:08:39.259><c> contracts</c>

00:08:39.879 --> 00:08:39.889 align:start position:0%
now if you want to optimize contracts
 

00:08:39.889 --> 00:08:42.249 align:start position:0%
now if you want to optimize contracts
you<00:08:40.399><c> should</c><00:08:40.610><c> also</c><00:08:40.789><c> do</c><00:08:41.060><c> optimization</c><00:08:41.719><c> steps</c><00:08:41.990><c> in</c>

00:08:42.249 --> 00:08:42.259 align:start position:0%
you should also do optimization steps in
 

00:08:42.259 --> 00:08:45.639 align:start position:0%
you should also do optimization steps in
solidity<00:08:43.069><c> in</c><00:08:43.579><c> the</c><00:08:43.669><c> solid</c><00:08:43.909><c> part</c><00:08:44.329><c> before</c><00:08:44.779><c> it</c>

00:08:45.639 --> 00:08:45.649 align:start position:0%
solidity in the solid part before it
 

00:08:45.649 --> 00:08:48.280 align:start position:0%
solidity in the solid part before it
gets<00:08:45.829><c> converted</c><00:08:46.100><c> to</c><00:08:46.310><c> EVM</c><00:08:46.699><c> and</c><00:08:46.970><c> in</c><00:08:47.750><c> fact</c><00:08:48.139><c> we</c>

00:08:48.280 --> 00:08:48.290 align:start position:0%
gets converted to EVM and in fact we
 

00:08:48.290 --> 00:08:51.610 align:start position:0%
gets converted to EVM and in fact we
only<00:08:48.319><c> have</c><00:08:48.649><c> one</c><00:08:48.920><c> single</c><00:08:49.610><c> tiny</c><00:08:50.620><c> simple</c>

00:08:51.610 --> 00:08:51.620 align:start position:0%
only have one single tiny simple
 

00:08:51.620 --> 00:08:53.980 align:start position:0%
only have one single tiny simple
optimization<00:08:52.370><c> step</c><00:08:52.610><c> in</c><00:08:52.790><c> solidity</c><00:08:53.209><c> everything</c>

00:08:53.980 --> 00:08:53.990 align:start position:0%
optimization step in solidity everything
 

00:08:53.990 --> 00:08:56.260 align:start position:0%
optimization step in solidity everything
else<00:08:54.170><c> is</c><00:08:54.380><c> in</c>

00:08:56.260 --> 00:08:56.270 align:start position:0%
else is in
 

00:08:56.270 --> 00:08:58.820 align:start position:0%
else is in
and<00:08:57.270><c> you</c><00:08:57.570><c> know</c><00:08:57.690><c> if</c><00:08:57.960><c> we</c><00:08:58.500><c> have</c><00:08:58.620><c> all</c><00:08:58.680><c> these</c>

00:08:58.820 --> 00:08:58.830 align:start position:0%
and you know if we have all these
 

00:08:58.830 --> 00:09:01.040 align:start position:0%
and you know if we have all these
helpers<00:08:59.160><c> written</c><00:08:59.460><c> in</c><00:08:59.550><c> Julia</c><00:08:59.850><c> and</c><00:09:00.150><c> they</c><00:09:00.930><c> are</c>

00:09:01.040 --> 00:09:01.050 align:start position:0%
helpers written in Julia and they are
 

00:09:01.050 --> 00:09:02.810 align:start position:0%
helpers written in Julia and they are
verified<00:09:01.410><c> they</c><00:09:02.100><c> could</c><00:09:02.280><c> be</c><00:09:02.400><c> used</c><00:09:02.610><c> by</c><00:09:02.790><c> other</c>

00:09:02.810 --> 00:09:02.820 align:start position:0%
verified they could be used by other
 

00:09:02.820 --> 00:09:06.110 align:start position:0%
verified they could be used by other
languages<00:09:03.300><c> as</c><00:09:03.540><c> well</c><00:09:03.750><c> in</c><00:09:03.990><c> the</c><00:09:04.410><c> ecosystem</c><00:09:05.120><c> so</c>

00:09:06.110 --> 00:09:06.120 align:start position:0%
languages as well in the ecosystem so
 

00:09:06.120 --> 00:09:10.790 align:start position:0%
languages as well in the ecosystem so
where<00:09:06.750><c> do</c><00:09:06.870><c> we</c><00:09:06.900><c> stand</c><00:09:07.260><c> right</c><00:09:07.440><c> now</c><00:09:09.590><c> Julia</c><00:09:10.590><c> I</c>

00:09:10.790 --> 00:09:10.800 align:start position:0%
where do we stand right now Julia I
 

00:09:10.800 --> 00:09:13.070 align:start position:0%
where do we stand right now Julia I
guess<00:09:11.070><c> looked</c><00:09:11.370><c> familiar</c><00:09:11.580><c> to</c><00:09:11.970><c> those</c><00:09:12.120><c> who</c><00:09:12.480><c> use</c>

00:09:13.070 --> 00:09:13.080 align:start position:0%
guess looked familiar to those who use
 

00:09:13.080 --> 00:09:14.990 align:start position:0%
guess looked familiar to those who use
solidity<00:09:13.560><c> because</c><00:09:14.250><c> it</c><00:09:14.370><c> looked</c><00:09:14.610><c> kind</c><00:09:14.880><c> of</c><00:09:14.940><c> like</c>

00:09:14.990 --> 00:09:15.000 align:start position:0%
solidity because it looked kind of like
 

00:09:15.000 --> 00:09:17.560 align:start position:0%
solidity because it looked kind of like
the<00:09:15.180><c> inline</c><00:09:15.450><c> assembly</c><00:09:15.930><c> solidity</c><00:09:16.740><c> has</c><00:09:17.010><c> and</c>

00:09:17.560 --> 00:09:17.570 align:start position:0%
the inline assembly solidity has and
 

00:09:17.570 --> 00:09:20.570 align:start position:0%
the inline assembly solidity has and
that's<00:09:18.570><c> of</c><00:09:18.690><c> course</c><00:09:18.720><c> because</c><00:09:19.020><c> it</c><00:09:19.380><c> is</c><00:09:19.580><c> an</c>

00:09:20.570 --> 00:09:20.580 align:start position:0%
that's of course because it is an
 

00:09:20.580 --> 00:09:23.810 align:start position:0%
that's of course because it is an
evolutionary<00:09:21.120><c> step</c><00:09:21.480><c> from</c><00:09:21.840><c> align</c><00:09:22.410><c> assembly</c><00:09:22.830><c> so</c>

00:09:23.810 --> 00:09:23.820 align:start position:0%
evolutionary step from align assembly so
 

00:09:23.820 --> 00:09:24.980 align:start position:0%
evolutionary step from align assembly so
you<00:09:23.910><c> know</c><00:09:24.000><c> somebody</c><00:09:24.330><c> was</c><00:09:24.480><c> introduced</c><00:09:24.840><c> last</c>

00:09:24.980 --> 00:09:24.990 align:start position:0%
you know somebody was introduced last
 

00:09:24.990 --> 00:09:28.010 align:start position:0%
you know somebody was introduced last
year<00:09:25.310><c> it's</c><00:09:26.310><c> supported</c><00:09:26.820><c> jumps</c><00:09:27.150><c> instructions</c>

00:09:28.010 --> 00:09:28.020 align:start position:0%
year it's supported jumps instructions
 

00:09:28.020 --> 00:09:31.100 align:start position:0%
year it's supported jumps instructions
and<00:09:28.230><c> functional</c><00:09:28.650><c> instructions</c><00:09:29.600><c> but</c><00:09:30.600><c> over</c>

00:09:31.100 --> 00:09:31.110 align:start position:0%
and functional instructions but over
 

00:09:31.110 --> 00:09:33.830 align:start position:0%
and functional instructions but over
time<00:09:31.350><c> we</c><00:09:31.590><c> have</c><00:09:31.710><c> restricted</c><00:09:32.310><c> that</c><00:09:32.450><c> we</c><00:09:33.450><c> remove</c>

00:09:33.830 --> 00:09:33.840 align:start position:0%
time we have restricted that we remove
 

00:09:33.840 --> 00:09:37.940 align:start position:0%
time we have restricted that we remove
the<00:09:34.940><c> you</c><00:09:35.940><c> know</c><00:09:36.060><c> more</c><00:09:36.240><c> risky</c><00:09:36.750><c> part</c><00:09:36.900><c> and</c><00:09:37.230><c> we</c>

00:09:37.940 --> 00:09:37.950 align:start position:0%
the you know more risky part and we
 

00:09:37.950 --> 00:09:39.230 align:start position:0%
the you know more risky part and we
added<00:09:38.130><c> a</c><00:09:38.280><c> couple</c><00:09:38.460><c> of</c><00:09:38.580><c> new</c><00:09:38.640><c> features</c><00:09:38.970><c> like</c>

00:09:39.230 --> 00:09:39.240 align:start position:0%
added a couple of new features like
 

00:09:39.240 --> 00:09:44.650 align:start position:0%
added a couple of new features like
functions<00:09:39.900><c> for</c><00:09:40.380><c> loops</c><00:09:40.590><c> which</c><00:09:41.070><c> statements</c><00:09:42.950><c> and</c>

00:09:44.650 --> 00:09:44.660 align:start position:0%
functions for loops which statements and
 

00:09:44.660 --> 00:09:48.620 align:start position:0%
functions for loops which statements and
yeah<00:09:46.190><c> okay</c><00:09:47.190><c> so</c><00:09:47.250><c> one</c><00:09:47.820><c> question</c><00:09:48.210><c> there</c>

00:09:48.620 --> 00:09:48.630 align:start position:0%
yeah okay so one question there
 

00:09:48.630 --> 00:09:51.950 align:start position:0%
yeah okay so one question there
I<00:09:48.660><c> guess</c><00:09:49.650><c> those</c><00:09:49.800><c> people</c><00:09:50.130><c> doing</c><00:09:50.900><c> serpent</c><00:09:51.900><c> the</c>

00:09:51.950 --> 00:09:51.960 align:start position:0%
I guess those people doing serpent the
 

00:09:51.960 --> 00:09:54.470 align:start position:0%
I guess those people doing serpent the
Viper<00:09:52.140><c> would</c><00:09:52.440><c> ask</c><00:09:52.620><c> why</c><00:09:53.370><c> not</c><00:09:53.640><c> do</c><00:09:53.850><c> it</c><00:09:53.880><c> with</c><00:09:54.030><c> LLL</c>

00:09:54.470 --> 00:09:54.480 align:start position:0%
Viper would ask why not do it with LLL
 

00:09:54.480 --> 00:09:57.320 align:start position:0%
Viper would ask why not do it with LLL
use<00:09:54.900><c> lll</c><00:09:55.230><c> axis</c><00:09:55.590><c> and</c><00:09:55.940><c> serpent</c><00:09:56.940><c> actually</c><00:09:57.210><c> use</c>

00:09:57.320 --> 00:09:57.330 align:start position:0%
use lll axis and serpent actually use
 

00:09:57.330 --> 00:10:00.830 align:start position:0%
use lll axis and serpent actually use
LLL<00:09:57.750><c> as</c><00:09:57.960><c> an</c><00:09:58.140><c> intermediate</c><00:09:58.590><c> language</c><00:09:59.000><c> so</c><00:10:00.000><c> the</c>

00:10:00.830 --> 00:10:00.840 align:start position:0%
LLL as an intermediate language so the
 

00:10:00.840 --> 00:10:03.350 align:start position:0%
LLL as an intermediate language so the
two<00:10:01.020><c> main</c><00:10:01.170><c> reasons</c><00:10:01.350><c> is</c><00:10:01.740><c> ll</c><00:10:02.430><c> L</c><00:10:02.580><c> is</c><00:10:02.790><c> really</c><00:10:03.060><c> based</c>

00:10:03.350 --> 00:10:03.360 align:start position:0%
two main reasons is ll L is really based
 

00:10:03.360 --> 00:10:05.630 align:start position:0%
two main reasons is ll L is really based
on<00:10:03.510><c> a</c><00:10:03.630><c> VM</c><00:10:03.900><c> it's</c><00:10:04.440><c> based</c><00:10:04.680><c> on</c><00:10:04.770><c> the</c><00:10:04.890><c> VM</c><00:10:05.160><c> opcodes</c>

00:10:05.630 --> 00:10:05.640 align:start position:0%
on a VM it's based on the VM opcodes
 

00:10:05.640 --> 00:10:07.850 align:start position:0%
on a VM it's based on the VM opcodes
it<00:10:06.060><c> has</c><00:10:06.180><c> a</c><00:10:06.210><c> couple</c><00:10:06.390><c> of</c><00:10:06.540><c> extensions</c><00:10:06.870><c> on</c><00:10:07.140><c> top</c><00:10:07.320><c> but</c>

00:10:07.850 --> 00:10:07.860 align:start position:0%
it has a couple of extensions on top but
 

00:10:07.860 --> 00:10:10.610 align:start position:0%
it has a couple of extensions on top but
it<00:10:07.950><c> really</c><00:10:08.160><c> is</c><00:10:08.400><c> just</c><00:10:08.430><c> a</c><00:10:09.420><c> VM</c><00:10:09.930><c> assembly</c><00:10:10.380><c> in</c><00:10:10.560><c> a</c>

00:10:10.610 --> 00:10:10.620 align:start position:0%
it really is just a VM assembly in a
 

00:10:10.620 --> 00:10:13.910 align:start position:0%
it really is just a VM assembly in a
lisp<00:10:11.070><c> like</c><00:10:11.340><c> language</c><00:10:11.760><c> and</c><00:10:12.470><c> of</c><00:10:13.470><c> course</c><00:10:13.680><c> we</c><00:10:13.800><c> have</c>

00:10:13.910 --> 00:10:13.920 align:start position:0%
lisp like language and of course we have
 

00:10:13.920 --> 00:10:15.650 align:start position:0%
lisp like language and of course we have
this<00:10:14.040><c> organic</c><00:10:14.400><c> evolution</c><00:10:14.640><c> of</c><00:10:15.210><c> inline</c>

00:10:15.650 --> 00:10:15.660 align:start position:0%
this organic evolution of inline
 

00:10:15.660 --> 00:10:19.760 align:start position:0%
this organic evolution of inline
assembly<00:10:16.080><c> which</c><00:10:16.620><c> was</c><00:10:16.650><c> already</c><00:10:16.890><c> used</c><00:10:18.200><c> so</c><00:10:19.200><c> the</c>

00:10:19.760 --> 00:10:19.770 align:start position:0%
assembly which was already used so the
 

00:10:19.770 --> 00:10:22.190 align:start position:0%
assembly which was already used so the
language<00:10:19.920><c> features</c><00:10:20.220><c> we</c><00:10:20.610><c> have</c><00:10:21.020><c> we</c><00:10:22.020><c> have</c>

00:10:22.190 --> 00:10:22.200 align:start position:0%
language features we have we have
 

00:10:22.200 --> 00:10:25.430 align:start position:0%
language features we have we have
variables<00:10:22.620><c> which</c><00:10:23.400><c> can</c><00:10:23.550><c> be</c><00:10:23.700><c> typed</c><00:10:24.230><c> well</c><00:10:25.230><c> in</c>

00:10:25.430 --> 00:10:25.440 align:start position:0%
variables which can be typed well in
 

00:10:25.440 --> 00:10:27.980 align:start position:0%
variables which can be typed well in
fact<00:10:25.880><c> there's</c><00:10:26.880><c> Julia</c><00:10:27.240><c> which</c><00:10:27.750><c> is</c><00:10:27.900><c> the</c>

00:10:27.980 --> 00:10:27.990 align:start position:0%
fact there's Julia which is the
 

00:10:27.990 --> 00:10:30.200 align:start position:0%
fact there's Julia which is the
intermediate<00:10:28.380><c> language</c><00:10:28.580><c> that</c><00:10:29.580><c> must</c><00:10:29.760><c> be</c><00:10:29.850><c> typed</c>

00:10:30.200 --> 00:10:30.210 align:start position:0%
intermediate language that must be typed
 

00:10:30.210 --> 00:10:33.140 align:start position:0%
intermediate language that must be typed
and<00:10:31.080><c> then</c><00:10:31.380><c> we</c><00:10:31.530><c> have</c><00:10:31.620><c> inline</c><00:10:31.890><c> assembly</c><00:10:32.310><c> which</c>

00:10:33.140 --> 00:10:33.150 align:start position:0%
and then we have inline assembly which
 

00:10:33.150 --> 00:10:36.220 align:start position:0%
and then we have inline assembly which
you<00:10:33.330><c> can</c><00:10:33.450><c> already</c><00:10:33.630><c> use</c><00:10:33.890><c> that</c><00:10:34.890><c> is</c><00:10:35.040><c> not</c><00:10:35.190><c> typed</c>

00:10:36.220 --> 00:10:36.230 align:start position:0%
you can already use that is not typed
 

00:10:36.230 --> 00:10:38.510 align:start position:0%
you can already use that is not typed
the<00:10:37.230><c> a</c><00:10:37.260><c> function</c><00:10:37.470><c> switch</c><00:10:37.950><c> statement</c>

00:10:38.510 --> 00:10:38.520 align:start position:0%
the a function switch statement
 

00:10:38.520 --> 00:10:41.540 align:start position:0%
the a function switch statement
I<00:10:39.680><c> guess</c><00:10:40.680><c> soon</c><00:10:40.860><c> we</c><00:10:41.040><c> will</c><00:10:41.190><c> have</c><00:10:41.340><c> an</c><00:10:41.430><c> if</c>

00:10:41.540 --> 00:10:41.550 align:start position:0%
I guess soon we will have an if
 

00:10:41.550 --> 00:10:43.460 align:start position:0%
I guess soon we will have an if
statement<00:10:41.730><c> as</c><00:10:42.120><c> well</c><00:10:42.300><c> video</c><00:10:42.870><c> today</c><00:10:43.200><c> else</c>

00:10:43.460 --> 00:10:43.470 align:start position:0%
statement as well video today else
 

00:10:43.470 --> 00:10:46.940 align:start position:0%
statement as well video today else
condition<00:10:44.340><c> and</c><00:10:44.660><c> via</c><00:10:45.660><c> for</c><00:10:45.900><c> loops</c><00:10:46.110><c> then</c>

00:10:46.940 --> 00:10:46.950 align:start position:0%
condition and via for loops then
 

00:10:46.950 --> 00:10:48.740 align:start position:0%
condition and via for loops then
important<00:10:47.430><c> part</c><00:10:47.700><c> we</c><00:10:48.390><c> don't</c><00:10:48.570><c> have</c>

00:10:48.740 --> 00:10:48.750 align:start position:0%
important part we don't have
 

00:10:48.750 --> 00:10:52.730 align:start position:0%
important part we don't have
instructions<00:10:49.940><c> evm</c><00:10:50.940><c> op</c><00:10:51.090><c> codes</c><00:10:51.470><c> behave</c><00:10:52.470><c> just</c>

00:10:52.730 --> 00:10:52.740 align:start position:0%
instructions evm op codes behave just
 

00:10:52.740 --> 00:10:54.680 align:start position:0%
instructions evm op codes behave just
like<00:10:52.800><c> functions</c><00:10:53.370><c> they</c><00:10:53.550><c> are</c><00:10:53.580><c> not</c><00:10:53.730><c> a</c><00:10:54.000><c> separate</c>

00:10:54.680 --> 00:10:54.690 align:start position:0%
like functions they are not a separate
 

00:10:54.690 --> 00:11:00.290 align:start position:0%
like functions they are not a separate
kind<00:10:55.110><c> of</c><00:10:55.970><c> expression</c><00:10:58.070><c> so</c><00:10:59.150><c> variables</c><00:11:00.150><c> and</c>

00:11:00.290 --> 00:11:00.300 align:start position:0%
kind of expression so variables and
 

00:11:00.300 --> 00:11:02.480 align:start position:0%
kind of expression so variables and
functions<00:11:00.480><c> this</c><00:11:01.410><c> support</c><00:11:02.220><c> multiple</c>

00:11:02.480 --> 00:11:02.490 align:start position:0%
functions this support multiple
 

00:11:02.490 --> 00:11:04.280 align:start position:0%
functions this support multiple
assignment<00:11:03.060><c> the</c><00:11:03.510><c> earliest</c><00:11:03.750><c> relies</c><00:11:04.050><c> to</c><00:11:04.170><c> the</c>

00:11:04.280 --> 00:11:04.290 align:start position:0%
assignment the earliest relies to the
 

00:11:04.290 --> 00:11:07.520 align:start position:0%
assignment the earliest relies to the
default<00:11:04.770><c> value</c><00:11:05.460><c> of</c><00:11:05.520><c> 0</c><00:11:05.910><c> and</c><00:11:06.320><c> functions</c><00:11:07.320><c> can</c>

00:11:07.520 --> 00:11:07.530 align:start position:0%
default value of 0 and functions can
 

00:11:07.530 --> 00:11:09.170 align:start position:0%
default value of 0 and functions can
have<00:11:07.560><c> multiple</c><00:11:08.040><c> inputs</c><00:11:08.190><c> and</c><00:11:08.550><c> multiplied</c>

00:11:09.170 --> 00:11:09.180 align:start position:0%
have multiple inputs and multiplied
 

00:11:09.180 --> 00:11:11.990 align:start position:0%
have multiple inputs and multiplied
so<00:11:10.170><c> here</c><00:11:10.470><c> here</c><00:11:10.800><c> are</c><00:11:10.860><c> a</c><00:11:10.890><c> couple</c><00:11:10.920><c> of</c><00:11:11.160><c> examples</c><00:11:11.280><c> on</c>

00:11:11.990 --> 00:11:12.000 align:start position:0%
so here here are a couple of examples on
 

00:11:12.000 --> 00:11:14.360 align:start position:0%
so here here are a couple of examples on
a<00:11:12.110><c> table</c><00:11:13.110><c> you</c><00:11:13.140><c> just</c><00:11:13.380><c> have</c><00:11:13.650><c> a</c><00:11:13.680><c> same</c><00:11:13.920><c> simple</c>

00:11:14.360 --> 00:11:14.370 align:start position:0%
a table you just have a same simple
 

00:11:14.370 --> 00:11:16.940 align:start position:0%
a table you just have a same simple
excitement<00:11:14.940><c> if</c><00:11:15.810><c> there's</c><00:11:16.440><c> no</c><00:11:16.590><c> where</c><00:11:16.830><c> you</c>

00:11:16.940 --> 00:11:16.950 align:start position:0%
excitement if there's no where you
 

00:11:16.950 --> 00:11:20.950 align:start position:0%
excitement if there's no where you
specify<00:11:17.190><c> it</c><00:11:17.520><c> as</c><00:11:17.730><c> assigned</c><00:11:18.120><c> a</c><00:11:18.480><c> zero</c><00:11:19.190><c> oh</c>

00:11:20.950 --> 00:11:20.960 align:start position:0%
specify it as assigned a zero oh
 

00:11:20.960 --> 00:11:25.130 align:start position:0%
specify it as assigned a zero oh
actually<00:11:21.960><c> the</c><00:11:22.860><c> third</c><00:11:23.010><c> line</c><00:11:23.280><c> is</c><00:11:23.900><c> invalid</c>

00:11:25.130 --> 00:11:25.140 align:start position:0%
actually the third line is invalid
 

00:11:25.140 --> 00:11:29.270 align:start position:0%
actually the third line is invalid
I<00:11:25.190><c> just</c><00:11:26.190><c> miss</c><00:11:27.030><c> to</c><00:11:27.240><c> market</c><00:11:27.890><c> because</c><00:11:28.890><c> right</c><00:11:29.100><c> hand</c>

00:11:29.270 --> 00:11:29.280 align:start position:0%
I just miss to market because right hand
 

00:11:29.280 --> 00:11:31.550 align:start position:0%
I just miss to market because right hand
side<00:11:29.520><c> has</c><00:11:30.000><c> to</c><00:11:30.030><c> be</c><00:11:30.240><c> a</c><00:11:30.510><c> single</c><00:11:30.960><c> expression</c><00:11:31.230><c> it</c>

00:11:31.550 --> 00:11:31.560 align:start position:0%
side has to be a single expression it
 

00:11:31.560 --> 00:11:34.310 align:start position:0%
side has to be a single expression it
cannot<00:11:31.770><c> be</c><00:11:31.950><c> a</c><00:11:31.980><c> tuple</c><00:11:32.280><c> expression</c><00:11:32.900><c> and</c><00:11:33.900><c> that</c><00:11:34.110><c> is</c>

00:11:34.310 --> 00:11:34.320 align:start position:0%
cannot be a tuple expression and that is
 

00:11:34.320 --> 00:11:35.570 align:start position:0%
cannot be a tuple expression and that is
a<00:11:34.350><c> simple</c><00:11:34.710><c> function</c><00:11:34.890><c> and</c><00:11:35.250><c> that's</c><00:11:35.400><c> how</c><00:11:35.520><c> you</c>

00:11:35.570 --> 00:11:35.580 align:start position:0%
a simple function and that's how you
 

00:11:35.580 --> 00:11:40.130 align:start position:0%
a simple function and that's how you
call<00:11:35.820><c> it</c><00:11:36.740><c> now</c><00:11:37.740><c> the</c><00:11:38.190><c> switch</c><00:11:38.430><c> statement</c><00:11:38.550><c> is</c><00:11:39.140><c> the</c>

00:11:40.130 --> 00:11:40.140 align:start position:0%
call it now the switch statement is the
 

00:11:40.140 --> 00:11:44.600 align:start position:0%
call it now the switch statement is the
core<00:11:40.440><c> of</c><00:11:41.240><c> the</c><00:11:42.240><c> entire</c><00:11:42.450><c> language</c><00:11:43.070><c> it</c><00:11:44.070><c> can</c><00:11:44.430><c> have</c>

00:11:44.600 --> 00:11:44.610 align:start position:0%
core of the entire language it can have
 

00:11:44.610 --> 00:11:45.950 align:start position:0%
core of the entire language it can have
multiple<00:11:44.940><c> cases</c><00:11:45.060><c> it</c><00:11:45.450><c> can</c><00:11:45.570><c> have</c><00:11:45.720><c> a</c><00:11:45.780><c> default</c>

00:11:45.950 --> 00:11:45.960 align:start position:0%
multiple cases it can have a default
 

00:11:45.960 --> 00:11:51.380 align:start position:0%
multiple cases it can have a default
value<00:11:46.550><c> at</c><00:11:47.550><c> least</c><00:11:48.210><c> one</c><00:11:48.540><c> case</c><00:11:48.830><c> either</c><00:11:50.390><c> specified</c>

00:11:51.380 --> 00:11:51.390 align:start position:0%
value at least one case either specified
 

00:11:51.390 --> 00:11:52.820 align:start position:0%
value at least one case either specified
case<00:11:51.570><c> or</c><00:11:51.720><c> the</c><00:11:51.810><c> default</c><00:11:52.080><c> case</c><00:11:52.230><c> has</c><00:11:52.620><c> to</c><00:11:52.740><c> be</c>

00:11:52.820 --> 00:11:52.830 align:start position:0%
case or the default case has to be
 

00:11:52.830 --> 00:11:56.180 align:start position:0%
case or the default case has to be
present<00:11:53.270><c> one</c><00:11:54.270><c> major</c><00:11:54.510><c> difference</c><00:11:54.780><c> here</c><00:11:55.190><c> for</c>

00:11:56.180 --> 00:11:56.190 align:start position:0%
present one major difference here for
 

00:11:56.190 --> 00:11:59.900 align:start position:0%
present one major difference here for
anyone<00:11:57.140><c> used</c><00:11:58.140><c> to</c><00:11:58.350><c> normal</c><00:11:58.800><c> languages</c><00:11:59.220><c> is</c><00:11:59.400><c> a</c>

00:11:59.900 --> 00:11:59.910 align:start position:0%
anyone used to normal languages is a
 

00:11:59.910 --> 00:12:01.910 align:start position:0%
anyone used to normal languages is a
switch<00:12:00.180><c> statement</c><00:12:00.300><c> with</c><00:12:00.840><c> support</c><00:12:01.350><c> for</c><00:12:01.620><c> true</c>

00:12:01.910 --> 00:12:01.920 align:start position:0%
switch statement with support for true
 

00:12:01.920 --> 00:12:04.430 align:start position:0%
switch statement with support for true
and<00:12:02.130><c> you</c><00:12:02.640><c> would</c><00:12:02.760><c> have</c><00:12:02.820><c> a</c><00:12:02.910><c> keyboard</c><00:12:03.210><c> break</c><00:12:03.540><c> to</c>

00:12:04.430 --> 00:12:04.440 align:start position:0%
and you would have a keyboard break to
 

00:12:04.440 --> 00:12:05.990 align:start position:0%
and you would have a keyboard break to
stop<00:12:04.620><c> at</c><00:12:04.740><c> any</c><00:12:04.830><c> given</c><00:12:05.100><c> point</c><00:12:05.280><c> of</c><00:12:05.460><c> time</c>

00:12:05.990 --> 00:12:06.000 align:start position:0%
stop at any given point of time
 

00:12:06.000 --> 00:12:08.650 align:start position:0%
stop at any given point of time
naturally<00:12:06.930><c> it</c><00:12:07.020><c> doesn't</c><00:12:07.230><c> have</c><00:12:07.380><c> that</c><00:12:07.590><c> every</c>

00:12:08.650 --> 00:12:08.660 align:start position:0%
naturally it doesn't have that every
 

00:12:08.660 --> 00:12:12.980 align:start position:0%
naturally it doesn't have that every
part<00:12:09.660><c> of</c><00:12:09.870><c> a</c><00:12:10.020><c> switch</c><00:12:10.260><c> statement</c><00:12:11.960><c> will</c><00:12:12.960><c> be</c>

00:12:12.980 --> 00:12:12.990 align:start position:0%
part of a switch statement will be
 

00:12:12.990 --> 00:12:15.440 align:start position:0%
part of a switch statement will be
executed<00:12:13.440><c> entirely</c><00:12:14.400><c> there's</c><00:12:14.700><c> no</c><00:12:14.880><c> break</c><00:12:15.120><c> and</c>

00:12:15.440 --> 00:12:15.450 align:start position:0%
executed entirely there's no break and
 

00:12:15.450 --> 00:12:18.020 align:start position:0%
executed entirely there's no break and
there's<00:12:16.020><c> no</c><00:12:16.200><c> fall</c><00:12:16.500><c> true</c><00:12:16.790><c> that's</c><00:12:17.790><c> a</c><00:12:17.850><c> very</c>

00:12:18.020 --> 00:12:18.030 align:start position:0%
there's no fall true that's a very
 

00:12:18.030 --> 00:12:20.500 align:start position:0%
there's no fall true that's a very
important<00:12:18.540><c> thing</c><00:12:18.720><c> but</c><00:12:19.260><c> it</c><00:12:19.410><c> might</c><00:12:19.560><c> not</c><00:12:19.740><c> look</c>

00:12:20.500 --> 00:12:20.510 align:start position:0%
important thing but it might not look
 

00:12:20.510 --> 00:12:25.640 align:start position:0%
important thing but it might not look
obvious<00:12:21.510><c> from</c><00:12:21.780><c> these</c><00:12:22.020><c> examples</c><00:12:24.350><c> so</c><00:12:25.350><c> basically</c>

00:12:25.640 --> 00:12:25.650 align:start position:0%
obvious from these examples so basically
 

00:12:25.650 --> 00:12:28.310 align:start position:0%
obvious from these examples so basically
how<00:12:25.830><c> this</c><00:12:26.010><c> gets</c><00:12:26.160><c> compiled</c><00:12:26.610><c> into</c><00:12:27.080><c> bytecode</c><00:12:28.080><c> is</c>

00:12:28.310 --> 00:12:28.320 align:start position:0%
how this gets compiled into bytecode is
 

00:12:28.320 --> 00:12:30.740 align:start position:0%
how this gets compiled into bytecode is
in<00:12:29.540><c> EVM</c>

00:12:30.740 --> 00:12:30.750 align:start position:0%
in EVM
 

00:12:30.750 --> 00:12:33.260 align:start position:0%
in EVM
it<00:12:31.200><c> will</c><00:12:31.410><c> do</c><00:12:31.500><c> a</c><00:12:31.560><c> couple</c><00:12:31.770><c> of</c><00:12:31.950><c> comparisons</c><00:12:32.550><c> does</c>

00:12:33.260 --> 00:12:33.270 align:start position:0%
it will do a couple of comparisons does
 

00:12:33.270 --> 00:12:36.440 align:start position:0%
it will do a couple of comparisons does
it<00:12:33.390><c> equal</c><00:12:33.540><c> zero</c><00:12:34.110><c> if</c><00:12:34.650><c> not</c><00:12:34.950><c> do</c><00:12:35.760><c> that</c><00:12:35.940><c> does</c><00:12:36.330><c> it</c>

00:12:36.440 --> 00:12:36.450 align:start position:0%
it equal zero if not do that does it
 

00:12:36.450 --> 00:12:38.690 align:start position:0%
it equal zero if not do that does it
equal<00:12:36.540><c> zero</c><00:12:37.080><c> does</c><00:12:37.290><c> it</c><00:12:37.410><c> equal</c><00:12:37.500><c> one</c><00:12:37.860><c> does</c><00:12:38.580><c> it</c>

00:12:38.690 --> 00:12:38.700 align:start position:0%
equal zero does it equal one does it
 

00:12:38.700 --> 00:12:43.100 align:start position:0%
equal zero does it equal one does it
equal<00:12:38.790><c> tails</c><00:12:39.180><c> if</c><00:12:39.990><c> not</c><00:12:40.290><c> else</c><00:12:40.640><c> and</c><00:12:41.870><c> the</c><00:12:42.870><c> last</c>

00:12:43.100 --> 00:12:43.110 align:start position:0%
equal tails if not else and the last
 

00:12:43.110 --> 00:12:46.040 align:start position:0%
equal tails if not else and the last
feature<00:12:43.410><c> we</c><00:12:43.800><c> have</c><00:12:43.830><c> is</c><00:12:44.250><c> for</c><00:12:44.880><c> loops</c><00:12:45.090><c> which</c><00:12:45.870><c> has</c>

00:12:46.040 --> 00:12:46.050 align:start position:0%
feature we have is for loops which has
 

00:12:46.050 --> 00:12:49.070 align:start position:0%
feature we have is for loops which has
an<00:12:46.170><c> initializer</c><00:12:46.620><c> has</c><00:12:47.100><c> a</c><00:12:47.540><c> condition</c><00:12:48.540><c> has</c><00:12:49.050><c> a</c>

00:12:49.070 --> 00:12:49.080 align:start position:0%
an initializer has a condition has a
 

00:12:49.080 --> 00:12:51.590 align:start position:0%
an initializer has a condition has a
post<00:12:49.410><c> block</c><00:12:49.590><c> on</c><00:12:49.740><c> the</c><00:12:49.830><c> block</c><00:12:50.010><c> now</c><00:12:50.600><c> one</c>

00:12:51.590 --> 00:12:51.600 align:start position:0%
post block on the block now one
 

00:12:51.600 --> 00:12:53.990 align:start position:0%
post block on the block now one
interesting<00:12:51.900><c> part</c><00:12:52.650><c> here</c><00:12:52.950><c> is</c><00:12:53.130><c> in</c><00:12:53.610><c> an</c>

00:12:53.990 --> 00:12:54.000 align:start position:0%
interesting part here is in an
 

00:12:54.000 --> 00:12:56.330 align:start position:0%
interesting part here is in an
initializer<00:12:54.480><c> so</c><00:12:55.380><c> actually</c><00:12:55.920><c> all</c><00:12:55.950><c> the</c><00:12:56.130><c> blocks</c>

00:12:56.330 --> 00:12:56.340 align:start position:0%
initializer so actually all the blocks
 

00:12:56.340 --> 00:12:58.880 align:start position:0%
initializer so actually all the blocks
initializer<00:12:56.940><c> block</c><00:12:57.360><c> and</c><00:12:57.570><c> post</c><00:12:57.780><c> block</c><00:12:58.020><c> there</c>

00:12:58.880 --> 00:12:58.890 align:start position:0%
initializer block and post block there
 

00:12:58.890 --> 00:13:01.610 align:start position:0%
initializer block and post block there
are<00:12:59.070><c> the</c><00:12:59.370><c> same</c><00:12:59.550><c> scope</c><00:12:59.900><c> so</c><00:13:00.900><c> any</c><00:13:01.080><c> variable</c>

00:13:01.610 --> 00:13:01.620 align:start position:0%
are the same scope so any variable
 

00:13:01.620 --> 00:13:03.920 align:start position:0%
are the same scope so any variable
created<00:13:02.070><c> in</c><00:13:02.190><c> the</c><00:13:02.280><c> initializer</c><00:13:02.700><c> is</c><00:13:03.000><c> valid</c><00:13:03.750><c> in</c>

00:13:03.920 --> 00:13:03.930 align:start position:0%
created in the initializer is valid in
 

00:13:03.930 --> 00:13:06.140 align:start position:0%
created in the initializer is valid in
the<00:13:04.290><c> for</c><00:13:04.500><c> loop</c><00:13:04.530><c> but</c><00:13:05.190><c> it's</c><00:13:05.370><c> not</c><00:13:05.460><c> valid</c><00:13:05.730><c> outside</c>

00:13:06.140 --> 00:13:06.150 align:start position:0%
the for loop but it's not valid outside
 

00:13:06.150 --> 00:13:09.560 align:start position:0%
the for loop but it's not valid outside
it<00:13:06.960><c> does</c><00:13:07.200><c> support</c><00:13:07.380><c> break</c><00:13:07.800><c> a</c><00:13:08.510><c> couple</c><00:13:09.510><c> of</c>

00:13:09.560 --> 00:13:09.570 align:start position:0%
it does support break a couple of
 

00:13:09.570 --> 00:13:15.320 align:start position:0%
it does support break a couple of
examples

00:13:15.320 --> 00:13:15.330 align:start position:0%
 
 

00:13:15.330 --> 00:13:19.260 align:start position:0%
 
okay<00:13:16.890><c> so</c><00:13:17.890><c> we</c><00:13:18.010><c> do</c><00:13:18.190><c> actually</c><00:13:18.399><c> have</c><00:13:18.760><c> different</c>

00:13:19.260 --> 00:13:19.270 align:start position:0%
okay so we do actually have different
 

00:13:19.270 --> 00:13:23.639 align:start position:0%
okay so we do actually have different
backends<00:13:19.480><c> in</c><00:13:20.250><c> solidity</c><00:13:21.250><c> for</c><00:13:21.850><c> Julia</c><00:13:22.350><c> right</c><00:13:23.350><c> now</c>

00:13:23.639 --> 00:13:23.649 align:start position:0%
backends in solidity for Julia right now
 

00:13:23.649 --> 00:13:26.190 align:start position:0%
backends in solidity for Julia right now
evm<00:13:24.160><c> the</c><00:13:24.610><c> normally</c><00:13:24.940><c> VM</c><00:13:25.149><c> we</c><00:13:25.270><c> have</c><00:13:25.420><c> is</c><00:13:25.660><c> is</c><00:13:26.020><c> of</c>

00:13:26.190 --> 00:13:26.200 align:start position:0%
evm the normally VM we have is is of
 

00:13:26.200 --> 00:13:28.860 align:start position:0%
evm the normally VM we have is is of
course<00:13:26.410><c> working</c><00:13:26.740><c> and</c><00:13:26.920><c> we</c><00:13:27.520><c> have</c><00:13:27.550><c> even</c><00:13:28.180><c> 1.5</c>

00:13:28.860 --> 00:13:28.870 align:start position:0%
course working and we have even 1.5
 

00:13:28.870 --> 00:13:31.590 align:start position:0%
course working and we have even 1.5
implemented<00:13:29.730><c> the</c><00:13:30.730><c> interesting</c><00:13:31.089><c> part</c><00:13:31.300><c> of</c><00:13:31.360><c> a</c><00:13:31.450><c> TV</c>

00:13:31.590 --> 00:13:31.600 align:start position:0%
implemented the interesting part of a TV
 

00:13:31.600 --> 00:13:35.550 align:start position:0%
implemented the interesting part of a TV
of<00:13:31.720><c> 1.5</c><00:13:32.260><c> is</c><00:13:32.440><c> that</c><00:13:33.010><c> it</c><00:13:33.130><c> supports</c><00:13:34.560><c> basically</c>

00:13:35.550 --> 00:13:35.560 align:start position:0%
of 1.5 is that it supports basically
 

00:13:35.560 --> 00:13:38.940 align:start position:0%
of 1.5 is that it supports basically
functions<00:13:35.980><c> and</c><00:13:36.300><c> stack</c><00:13:37.300><c> frames</c><00:13:37.570><c> and</c><00:13:38.410><c> so</c><00:13:38.770><c> it's</c>

00:13:38.940 --> 00:13:38.950 align:start position:0%
functions and stack frames and so it's
 

00:13:38.950 --> 00:13:41.449 align:start position:0%
functions and stack frames and so it's
you<00:13:39.580><c> know</c><00:13:39.700><c> that's</c><00:13:39.820><c> the</c><00:13:39.940><c> main</c><00:13:40.089><c> improvement</c>

00:13:41.449 --> 00:13:41.459 align:start position:0%
you know that's the main improvement
 

00:13:41.459 --> 00:13:44.370 align:start position:0%
you know that's the main improvement
what<00:13:42.459><c> it</c><00:13:42.610><c> means</c><00:13:42.820><c> we</c><00:13:43.240><c> can</c><00:13:43.510><c> really</c><00:13:44.050><c> easily</c>

00:13:44.370 --> 00:13:44.380 align:start position:0%
what it means we can really easily
 

00:13:44.380 --> 00:13:47.670 align:start position:0%
what it means we can really easily
translate<00:13:44.950><c> julia</c><00:13:45.339><c> functions</c><00:13:45.850><c> into</c><00:13:46.690><c> idiom</c><00:13:47.080><c> 1.5</c>

00:13:47.670 --> 00:13:47.680 align:start position:0%
translate julia functions into idiom 1.5
 

00:13:47.680 --> 00:13:50.639 align:start position:0%
translate julia functions into idiom 1.5
functions<00:13:48.550><c> and</c><00:13:48.820><c> that</c><00:13:49.779><c> makes</c><00:13:50.020><c> it</c><00:13:50.140><c> really</c><00:13:50.290><c> easy</c>

00:13:50.639 --> 00:13:50.649 align:start position:0%
functions and that makes it really easy
 

00:13:50.649 --> 00:13:54.900 align:start position:0%
functions and that makes it really easy
to<00:13:50.860><c> verify</c><00:13:52.860><c> it</c><00:13:53.860><c> was</c><00:13:54.100><c> a</c><00:13:54.130><c> is</c><00:13:54.490><c> a</c><00:13:54.760><c> different</c>

00:13:54.900 --> 00:13:54.910 align:start position:0%
to verify it was a is a different
 

00:13:54.910 --> 00:13:57.540 align:start position:0%
to verify it was a is a different
back-end<00:13:55.270><c> which</c><00:13:55.870><c> is</c><00:13:56.080><c> in</c><00:13:56.230><c> progress</c><00:13:56.440><c> it</c><00:13:57.310><c> already</c>

00:13:57.540 --> 00:13:57.550 align:start position:0%
back-end which is in progress it already
 

00:13:57.550 --> 00:13:59.070 align:start position:0%
back-end which is in progress it already
works<00:13:57.850><c> but</c><00:13:58.240><c> it's</c><00:13:58.360><c> not</c><00:13:58.510><c> finished</c>

00:13:59.070 --> 00:13:59.080 align:start position:0%
works but it's not finished
 

00:13:59.080 --> 00:14:01.790 align:start position:0%
works but it's not finished
so<00:13:59.740><c> it's</c><00:13:59.860><c> not</c><00:13:59.980><c> really</c><00:14:00.190><c> part</c><00:14:00.399><c> of</c><00:14:00.520><c> the</c><00:14:00.640><c> tree</c><00:14:00.850><c> yet</c>

00:14:01.790 --> 00:14:01.800 align:start position:0%
so it's not really part of the tree yet
 

00:14:01.800 --> 00:14:04.050 align:start position:0%
so it's not really part of the tree yet
the<00:14:02.800><c> last</c><00:14:03.220><c> back-end</c>

00:14:04.050 --> 00:14:04.060 align:start position:0%
the last back-end
 

00:14:04.060 --> 00:14:06.690 align:start position:0%
the last back-end
I<00:14:04.089><c> think</c><00:14:04.570><c> possible</c><00:14:05.110><c> is</c><00:14:05.459><c> even</c><00:14:06.459><c> doing</c><00:14:06.640><c> a</c>

00:14:06.690 --> 00:14:06.700 align:start position:0%
I think possible is even doing a
 

00:14:06.700 --> 00:14:09.300 align:start position:0%
I think possible is even doing a
JavaScript<00:14:07.149><c> back-end</c><00:14:07.990><c> the</c><00:14:08.649><c> use</c><00:14:08.830><c> case</c><00:14:09.100><c> there</c>

00:14:09.300 --> 00:14:09.310 align:start position:0%
JavaScript back-end the use case there
 

00:14:09.310 --> 00:14:12.750 align:start position:0%
JavaScript back-end the use case there
would<00:14:09.520><c> be</c><00:14:09.630><c> someone</c><00:14:10.630><c> is</c><00:14:10.810><c> writing</c><00:14:11.640><c> you</c><00:14:12.640><c> know</c>

00:14:12.750 --> 00:14:12.760 align:start position:0%
would be someone is writing you know
 

00:14:12.760 --> 00:14:15.449 align:start position:0%
would be someone is writing you know
more<00:14:13.149><c> more</c><00:14:13.480><c> parts</c><00:14:13.779><c> of</c><00:14:13.839><c> the</c><00:14:13.899><c> application</c><00:14:14.620><c> they</c>

00:14:15.449 --> 00:14:15.459 align:start position:0%
more more parts of the application they
 

00:14:15.459 --> 00:14:17.970 align:start position:0%
more more parts of the application they
tap<00:14:15.730><c> in</c><00:14:16.060><c> solidity</c><00:14:16.779><c> right</c><00:14:17.470><c> now</c><00:14:17.620><c> you</c><00:14:17.680><c> have</c><00:14:17.890><c> to</c>

00:14:17.970 --> 00:14:17.980 align:start position:0%
tap in solidity right now you have to
 

00:14:17.980 --> 00:14:21.030 align:start position:0%
tap in solidity right now you have to
only<00:14:18.100><c> write</c><00:14:18.279><c> account</c><00:14:18.640><c> D</c><00:14:18.850><c> on</c><00:14:19.300><c> chains</c><00:14:20.020><c> part</c><00:14:20.800><c> in</c>

00:14:21.030 --> 00:14:21.040 align:start position:0%
only write account D on chains part in
 

00:14:21.040 --> 00:14:24.410 align:start position:0%
only write account D on chains part in
solidity<00:14:21.850><c> but</c><00:14:22.750><c> you</c><00:14:22.930><c> could</c><00:14:23.170><c> in</c><00:14:23.560><c> the</c><00:14:23.800><c> future</c>

00:14:24.410 --> 00:14:24.420 align:start position:0%
solidity but you could in the future
 

00:14:24.420 --> 00:14:27.269 align:start position:0%
solidity but you could in the future
right<00:14:25.420><c> off</c><00:14:25.779><c> chain</c><00:14:26.080><c> parts</c><00:14:26.410><c> in</c><00:14:26.560><c> solidity</c><00:14:27.070><c> and</c>

00:14:27.269 --> 00:14:27.279 align:start position:0%
right off chain parts in solidity and
 

00:14:27.279 --> 00:14:30.930 align:start position:0%
right off chain parts in solidity and
compile<00:14:28.150><c> those</c><00:14:28.300><c> parts</c><00:14:28.720><c> into</c><00:14:29.170><c> JavaScript</c><00:14:29.940><c> if</c>

00:14:30.930 --> 00:14:30.940 align:start position:0%
compile those parts into JavaScript if
 

00:14:30.940 --> 00:14:33.060 align:start position:0%
compile those parts into JavaScript if
anyone<00:14:31.270><c> volunteers</c><00:14:31.750><c> I'm</c><00:14:31.959><c> happy</c><00:14:32.200><c> to</c><00:14:32.320><c> help</c><00:14:32.440><c> to</c>

00:14:33.060 --> 00:14:33.070 align:start position:0%
anyone volunteers I'm happy to help to
 

00:14:33.070 --> 00:14:36.269 align:start position:0%
anyone volunteers I'm happy to help to
get<00:14:33.250><c> that</c><00:14:33.459><c> back</c><00:14:33.760><c> and</c><00:14:33.910><c> down</c><00:14:34.140><c> and</c><00:14:35.140><c> we</c><00:14:36.130><c> already</c>

00:14:36.269 --> 00:14:36.279 align:start position:0%
get that back and down and we already
 

00:14:36.279 --> 00:14:38.570 align:start position:0%
get that back and down and we already
have<00:14:36.550><c> a</c><00:14:36.580><c> tiny</c><00:14:37.330><c> bit</c><00:14:37.570><c> of</c><00:14:37.600><c> third-party</c><00:14:38.020><c> support</c>

00:14:38.570 --> 00:14:38.580 align:start position:0%
have a tiny bit of third-party support
 

00:14:38.580 --> 00:14:42.510 align:start position:0%
have a tiny bit of third-party support
for<00:14:39.580><c> Julia</c><00:14:40.110><c> there</c><00:14:41.110><c> is</c><00:14:41.320><c> a</c><00:14:41.560><c> Julia</c><00:14:41.950><c> interpreter</c>

00:14:42.510 --> 00:14:42.520 align:start position:0%
for Julia there is a Julia interpreter
 

00:14:42.520 --> 00:14:45.420 align:start position:0%
for Julia there is a Julia interpreter
named<00:14:42.640><c> lamp</c><00:14:43.230><c> and</c><00:14:44.230><c> that's</c><00:14:44.470><c> the</c><00:14:44.650><c> URL</c><00:14:44.800><c> for</c><00:14:45.190><c> it</c><00:14:45.220><c> I</c>

00:14:45.420 --> 00:14:45.430 align:start position:0%
named lamp and that's the URL for it I
 

00:14:45.430 --> 00:14:47.329 align:start position:0%
named lamp and that's the URL for it I
think<00:14:46.000><c> it</c><00:14:46.180><c> was</c><00:14:46.360><c> written</c><00:14:46.540><c> in</c><00:14:46.779><c> less</c><00:14:46.959><c> than</c><00:14:47.080><c> a</c><00:14:47.170><c> week</c>

00:14:47.329 --> 00:14:47.339 align:start position:0%
think it was written in less than a week
 

00:14:47.339 --> 00:14:49.650 align:start position:0%
think it was written in less than a week
so<00:14:48.339><c> they're</c><00:14:48.760><c> probably</c><00:14:48.910><c> shows</c><00:14:49.360><c> that</c><00:14:49.570><c> the</c>

00:14:49.650 --> 00:14:49.660 align:start position:0%
so they're probably shows that the
 

00:14:49.660 --> 00:14:52.910 align:start position:0%
so they're probably shows that the
language<00:14:49.990><c> is</c><00:14:50.110><c> quite</c><00:14:50.290><c> simple</c><00:14:50.740><c> to</c><00:14:50.920><c> deal</c><00:14:51.160><c> with</c><00:14:51.400><c> I</c>

00:14:52.910 --> 00:14:52.920 align:start position:0%
language is quite simple to deal with I
 

00:14:52.920 --> 00:14:57.000 align:start position:0%
language is quite simple to deal with I
did<00:14:53.920><c> a</c><00:14:54.070><c> toy</c><00:14:54.459><c> LLL</c><00:14:55.029><c> to</c><00:14:55.329><c> julia</c><00:14:55.690><c> compiler</c><00:14:56.110><c> just</c><00:14:56.890><c> to</c>

00:14:57.000 --> 00:14:57.010 align:start position:0%
did a toy LLL to julia compiler just to
 

00:14:57.010 --> 00:14:58.769 align:start position:0%
did a toy LLL to julia compiler just to
see<00:14:57.190><c> you</c><00:14:57.430><c> know</c><00:14:57.579><c> how</c><00:14:58.089><c> much</c><00:14:58.240><c> effort</c><00:14:58.390><c> would</c><00:14:58.690><c> it</c>

00:14:58.769 --> 00:14:58.779 align:start position:0%
see you know how much effort would it
 

00:14:58.779 --> 00:15:01.530 align:start position:0%
see you know how much effort would it
take<00:14:58.959><c> it</c><00:14:59.440><c> takes</c><00:14:59.650><c> a</c><00:14:59.740><c> couple</c><00:14:59.890><c> of</c><00:15:00.040><c> hours</c><00:15:00.220><c> to</c><00:15:01.120><c> write</c>

00:15:01.530 --> 00:15:01.540 align:start position:0%
take it takes a couple of hours to write
 

00:15:01.540 --> 00:15:04.819 align:start position:0%
take it takes a couple of hours to write
it<00:15:01.779><c> even</c><00:15:01.959><c> less</c><00:15:02.410><c> if</c><00:15:02.620><c> you</c><00:15:02.800><c> have</c><00:15:03.040><c> a</c><00:15:03.279><c> parser</c><00:15:03.760><c> ready</c>

00:15:04.819 --> 00:15:04.829 align:start position:0%
it even less if you have a parser ready
 

00:15:04.829 --> 00:15:08.639 align:start position:0%
it even less if you have a parser ready
and<00:15:05.829><c> lastly</c><00:15:06.810><c> you</c><00:15:07.810><c> know</c><00:15:07.930><c> with</c><00:15:08.079><c> julia</c><00:15:08.380><c> it</c><00:15:08.470><c> should</c>

00:15:08.639 --> 00:15:08.649 align:start position:0%
and lastly you know with julia it should
 

00:15:08.649 --> 00:15:10.470 align:start position:0%
and lastly you know with julia it should
be<00:15:08.770><c> easy</c><00:15:08.950><c> enough</c><00:15:09.250><c> to</c><00:15:09.610><c> create</c><00:15:10.060><c> domain-specific</c>

00:15:10.470 --> 00:15:10.480 align:start position:0%
be easy enough to create domain-specific
 

00:15:10.480 --> 00:15:13.380 align:start position:0%
be easy enough to create domain-specific
languages<00:15:11.230><c> because</c><00:15:12.190><c> julia</c><00:15:12.970><c> is</c><00:15:13.029><c> quite</c><00:15:13.209><c> low</c>

00:15:13.380 --> 00:15:13.390 align:start position:0%
languages because julia is quite low
 

00:15:13.390 --> 00:15:15.660 align:start position:0%
languages because julia is quite low
level<00:15:13.720><c> but</c><00:15:14.410><c> at</c><00:15:14.620><c> the</c><00:15:14.709><c> same</c><00:15:14.829><c> time</c><00:15:15.070><c> it</c><00:15:15.220><c> does</c><00:15:15.459><c> have</c>

00:15:15.660 --> 00:15:15.670 align:start position:0%
level but at the same time it does have
 

00:15:15.670 --> 00:15:17.579 align:start position:0%
level but at the same time it does have
a<00:15:15.700><c> lot</c><00:15:15.880><c> of</c><00:15:15.910><c> convenient</c><00:15:16.870><c> features</c><00:15:17.230><c> like</c>

00:15:17.579 --> 00:15:17.589 align:start position:0%
a lot of convenient features like
 

00:15:17.589 --> 00:15:22.350 align:start position:0%
a lot of convenient features like
functions<00:15:18.100><c> and</c><00:15:18.339><c> switch</c><00:15:18.520><c> statements</c><00:15:21.240><c> that</c><00:15:22.240><c> is</c>

00:15:22.350 --> 00:15:22.360 align:start position:0%
functions and switch statements that is
 

00:15:22.360 --> 00:15:24.630 align:start position:0%
functions and switch statements that is
actually<00:15:22.720><c> example</c><00:15:23.110><c> of</c><00:15:23.290><c> compiling</c>

00:15:24.630 --> 00:15:24.640 align:start position:0%
actually example of compiling
 

00:15:24.640 --> 00:15:27.660 align:start position:0%
actually example of compiling
LLL<00:15:25.240><c> to</c><00:15:25.390><c> Julia</c><00:15:25.690><c> and</c><00:15:25.900><c> as</c><00:15:26.830><c> you</c><00:15:26.950><c> can</c><00:15:27.100><c> see</c><00:15:27.160><c> most</c><00:15:27.580><c> of</c>

00:15:27.660 --> 00:15:27.670 align:start position:0%
LLL to Julia and as you can see most of
 

00:15:27.670 --> 00:15:31.290 align:start position:0%
LLL to Julia and as you can see most of
those<00:15:27.820><c> parts</c><00:15:28.320><c> entirely</c><00:15:29.320><c> resemble</c><00:15:30.300><c> lll</c>

00:15:31.290 --> 00:15:31.300 align:start position:0%
those parts entirely resemble lll
 

00:15:31.300 --> 00:15:34.320 align:start position:0%
those parts entirely resemble lll
counterparts<00:15:32.020><c> it</c><00:15:33.010><c> is</c><00:15:33.190><c> also</c><00:15:33.430><c> highlights</c><00:15:34.150><c> the</c>

00:15:34.320 --> 00:15:34.330 align:start position:0%
counterparts it is also highlights the
 

00:15:34.330 --> 00:15:38.190 align:start position:0%
counterparts it is also highlights the
need<00:15:35.200><c> for</c><00:15:35.260><c> optimizations</c><00:15:36.330><c> because</c><00:15:37.330><c> the</c><00:15:37.930><c> first</c>

00:15:38.190 --> 00:15:38.200 align:start position:0%
need for optimizations because the first
 

00:15:38.200 --> 00:15:41.730 align:start position:0%
need for optimizations because the first
step<00:15:38.380><c> in</c><00:15:38.800><c> using</c><00:15:39.640><c> julia</c><00:15:40.380><c> converting</c><00:15:41.380><c> from</c><00:15:41.500><c> any</c>

00:15:41.730 --> 00:15:41.740 align:start position:0%
step in using julia converting from any
 

00:15:41.740 --> 00:15:44.850 align:start position:0%
step in using julia converting from any
language<00:15:42.010><c> to</c><00:15:42.220><c> julia</c><00:15:42.670><c> is</c><00:15:43.350><c> to</c><00:15:44.350><c> be</c><00:15:44.470><c> able</c><00:15:44.560><c> to</c>

00:15:44.850 --> 00:15:44.860 align:start position:0%
language to julia is to be able to
 

00:15:44.860 --> 00:15:48.930 align:start position:0%
language to julia is to be able to
ensure<00:15:46.080><c> the</c><00:15:47.080><c> code</c><00:15:47.320><c> is</c><00:15:47.470><c> correct</c><00:15:47.860><c> so</c><00:15:48.520><c> it</c><00:15:48.640><c> will</c><00:15:48.790><c> be</c>

00:15:48.930 --> 00:15:48.940 align:start position:0%
ensure the code is correct so it will be
 

00:15:48.940 --> 00:15:51.510 align:start position:0%
ensure the code is correct so it will be
verbose<00:15:49.620><c> there</c><00:15:50.620><c> won't</c><00:15:50.770><c> be</c><00:15:50.830><c> any</c><00:15:51.010><c> optimization</c>

00:15:51.510 --> 00:15:51.520 align:start position:0%
verbose there won't be any optimization
 

00:15:51.520 --> 00:15:54.570 align:start position:0%
verbose there won't be any optimization
at<00:15:51.640><c> that</c><00:15:51.790><c> level</c><00:15:52.000><c> and</c><00:15:52.300><c> the</c><00:15:53.140><c> next</c><00:15:53.440><c> step</c><00:15:53.650><c> one</c><00:15:54.370><c> can</c>

00:15:54.570 --> 00:15:54.580 align:start position:0%
at that level and the next step one can
 

00:15:54.580 --> 00:15:57.180 align:start position:0%
at that level and the next step one can
apply<00:15:54.840><c> simple</c><00:15:55.840><c> optimizations</c><00:15:56.470><c> step</c><00:15:56.710><c> by</c><00:15:56.890><c> step</c>

00:15:57.180 --> 00:15:57.190 align:start position:0%
apply simple optimizations step by step
 

00:15:57.190 --> 00:16:00.330 align:start position:0%
apply simple optimizations step by step
so<00:15:57.760><c> in</c><00:15:57.940><c> this</c><00:15:58.090><c> case</c><00:15:58.300><c> here</c><00:15:58.600><c> I</c><00:15:59.010><c> would</c><00:16:00.010><c> want</c><00:16:00.220><c> the</c>

00:16:00.330 --> 00:16:00.340 align:start position:0%
so in this case here I would want the
 

00:16:00.340 --> 00:16:02.550 align:start position:0%
so in this case here I would want the
LLL<00:16:00.670><c> -</c><00:16:00.820><c> Julia</c><00:16:01.120><c> compiler</c><00:16:01.510><c> to</c><00:16:01.750><c> output</c><00:16:02.140><c> this</c><00:16:02.290><c> code</c>

00:16:02.550 --> 00:16:02.560 align:start position:0%
LLL - Julia compiler to output this code
 

00:16:02.560 --> 00:16:05.400 align:start position:0%
LLL - Julia compiler to output this code
but<00:16:03.340><c> it's</c><00:16:03.760><c> not</c><00:16:03.820><c> really</c><00:16:04.090><c> optimized</c><00:16:04.480><c> so</c><00:16:05.230><c> the</c>

00:16:05.400 --> 00:16:05.410 align:start position:0%
but it's not really optimized so the
 

00:16:05.410 --> 00:16:08.130 align:start position:0%
but it's not really optimized so the
next<00:16:05.590><c> step</c><00:16:05.830><c> I</c><00:16:06.100><c> would</c><00:16:06.460><c> want</c><00:16:06.760><c> an</c><00:16:06.880><c> optimizer</c><00:16:07.330><c> to</c>

00:16:08.130 --> 00:16:08.140 align:start position:0%
next step I would want an optimizer to
 

00:16:08.140 --> 00:16:12.180 align:start position:0%
next step I would want an optimizer to
inline<00:16:08.560><c> a</c><00:16:08.860><c> node</c><00:16:09.240><c> so</c><00:16:10.240><c> below</c><00:16:10.960><c> get</c><00:16:11.920><c> owner</c>

00:16:12.180 --> 00:16:12.190 align:start position:0%
inline a node so below get owner
 

00:16:12.190 --> 00:16:15.180 align:start position:0%
inline a node so below get owner
wouldn't<00:16:12.670><c> call</c><00:16:12.880><c> node</c><00:16:13.390><c> it</c><00:16:13.810><c> would</c><00:16:14.530><c> just</c><00:16:14.800><c> have</c>

00:16:15.180 --> 00:16:15.190 align:start position:0%
wouldn't call node it would just have
 

00:16:15.190 --> 00:16:19.350 align:start position:0%
wouldn't call node it would just have
called<00:16:15.580><c> data</c><00:16:16.320><c> as</c><00:16:17.320><c> code</c><00:16:18.040><c> eight</c><00:16:18.190><c> a</c><00:16:18.220><c> load</c><00:16:18.490><c> as</c><00:16:19.120><c> an</c>

00:16:19.350 --> 00:16:19.360 align:start position:0%
called data as code eight a load as an
 

00:16:19.360 --> 00:16:24.050 align:start position:0%
called data as code eight a load as an
instruction<00:16:21.960><c> so</c><00:16:22.960><c> that's</c><00:16:23.170><c> just</c><00:16:23.320><c> an</c><00:16:23.470><c> overview</c>

00:16:24.050 --> 00:16:24.060 align:start position:0%
instruction so that's just an overview
 

00:16:24.060 --> 00:16:25.950 align:start position:0%
instruction so that's just an overview
what<00:16:25.060><c> happened</c><00:16:25.390><c> in</c><00:16:25.480><c> the</c><00:16:25.570><c> last</c><00:16:25.690><c> couple</c><00:16:25.780><c> of</c>

00:16:25.950 --> 00:16:25.960 align:start position:0%
what happened in the last couple of
 

00:16:25.960 --> 00:16:28.980 align:start position:0%
what happened in the last couple of
months<00:16:26.140><c> regarding</c><00:16:27.070><c> solidity</c><00:16:27.460><c> and</c><00:16:27.670><c> Julia</c><00:16:27.990><c> and</c>

00:16:28.980 --> 00:16:28.990 align:start position:0%
months regarding solidity and Julia and
 

00:16:28.990 --> 00:16:31.830 align:start position:0%
months regarding solidity and Julia and
as<00:16:29.110><c> you</c><00:16:29.200><c> can</c><00:16:29.320><c> see</c><00:16:29.380><c> in</c><00:16:29.770><c> point</c><00:16:30.550><c> 12</c><00:16:30.940><c> we</c><00:16:31.810><c> have</c>

00:16:31.830 --> 00:16:31.840 align:start position:0%
as you can see in point 12 we have
 

00:16:31.840 --> 00:16:34.380 align:start position:0%
as you can see in point 12 we have
released<00:16:32.470><c> support</c><00:16:33.250><c> for</c><00:16:33.370><c> functions</c><00:16:33.820><c> for</c><00:16:34.150><c> loops</c>

00:16:34.380 --> 00:16:34.390 align:start position:0%
released support for functions for loops
 

00:16:34.390 --> 00:16:38.790 align:start position:0%
released support for functions for loops
and<00:16:35.340><c> point</c><00:16:36.340><c> 17</c><00:16:36.910><c> which</c><00:16:37.660><c> was</c><00:16:37.690><c> recently</c><00:16:38.200><c> the</c>

00:16:38.790 --> 00:16:38.800 align:start position:0%
and point 17 which was recently the
 

00:16:38.800 --> 00:16:42.960 align:start position:0%
and point 17 which was recently the
added<00:16:39.070><c> support</c><00:16:39.280><c> for</c><00:16:39.910><c> a</c><00:16:40.170><c> new</c><00:16:41.170><c> ABI</c><00:16:41.590><c> encoder</c><00:16:42.070><c> so</c>

00:16:42.960 --> 00:16:42.970 align:start position:0%
added support for a new ABI encoder so
 

00:16:42.970 --> 00:16:46.260 align:start position:0%
added support for a new ABI encoder so
many<00:16:43.180><c> people</c><00:16:43.510><c> who</c><00:16:43.810><c> were</c><00:16:44.770><c> complaining</c><00:16:45.280><c> the</c>

00:16:46.260 --> 00:16:46.270 align:start position:0%
many people who were complaining the
 

00:16:46.270 --> 00:16:49.680 align:start position:0%
many people who were complaining the
lack<00:16:46.480><c> of</c><00:16:46.510><c> support</c><00:16:47.020><c> for</c><00:16:47.230><c> structs</c><00:16:48.180><c> that</c><00:16:49.180><c> new</c><00:16:49.360><c> ABI</c>

00:16:49.680 --> 00:16:49.690 align:start position:0%
lack of support for structs that new ABI
 

00:16:49.690 --> 00:16:53.160 align:start position:0%
lack of support for structs that new ABI
encoder<00:16:50.140><c> enables</c><00:16:50.980><c> support</c><00:16:51.940><c> for</c><00:16:52.300><c> passing</c>

00:16:53.160 --> 00:16:53.170 align:start position:0%
encoder enables support for passing
 

00:16:53.170 --> 00:16:55.620 align:start position:0%
encoder enables support for passing
structs<00:16:53.590><c> between</c><00:16:53.920><c> functions</c><00:16:54.430><c> now</c><00:16:55.240><c> that's</c>

00:16:55.620 --> 00:16:55.630 align:start position:0%
structs between functions now that's
 

00:16:55.630 --> 00:16:57.300 align:start position:0%
structs between functions now that's
already<00:16:55.840><c> in</c><00:16:56.020><c> the</c><00:16:56.110><c> compiler</c><00:16:56.500><c> but</c><00:16:56.770><c> it</c><00:16:56.890><c> has</c><00:16:57.040><c> to</c><00:16:57.190><c> be</c>

00:16:57.300 --> 00:16:57.310 align:start position:0%
already in the compiler but it has to be
 

00:16:57.310 --> 00:17:00.710 align:start position:0%
already in the compiler but it has to be
enabled<00:16:57.490><c> by</c><00:16:57.940><c> a</c><00:16:57.970><c> special</c><00:16:58.680><c> experimental</c><00:16:59.680><c> switch</c>

00:17:00.710 --> 00:17:00.720 align:start position:0%
enabled by a special experimental switch
 

00:17:00.720 --> 00:17:03.510 align:start position:0%
enabled by a special experimental switch
because<00:17:01.720><c> you</c><00:17:02.080><c> know</c><00:17:02.170><c> we're</c><00:17:02.350><c> not</c><00:17:02.500><c> we're</c><00:17:03.370><c> not</c>

00:17:03.510 --> 00:17:03.520 align:start position:0%
because you know we're not we're not
 

00:17:03.520 --> 00:17:05.069 align:start position:0%
because you know we're not we're not
really<00:17:03.700><c> confident</c><00:17:04.060><c> yet</c><00:17:04.329><c> that</c><00:17:04.750><c> it</c><00:17:04.839><c> should</c><00:17:04.990><c> be</c>

00:17:05.069 --> 00:17:05.079 align:start position:0%
really confident yet that it should be
 

00:17:05.079 --> 00:17:06.840 align:start position:0%
really confident yet that it should be
used<00:17:05.260><c> in</c><00:17:05.410><c> production</c><00:17:05.650><c> but</c><00:17:06.310><c> if</c><00:17:06.430><c> someone</c><00:17:06.699><c> wants</c>

00:17:06.840 --> 00:17:06.850 align:start position:0%
used in production but if someone wants
 

00:17:06.850 --> 00:17:09.470 align:start position:0%
used in production but if someone wants
to<00:17:06.910><c> try</c><00:17:07.150><c> out</c><00:17:07.180><c> it</c><00:17:07.480><c> it's</c><00:17:07.690><c> certainly</c><00:17:08.020><c> possible</c>

00:17:09.470 --> 00:17:09.480 align:start position:0%
to try out it it's certainly possible
 

00:17:09.480 --> 00:17:12.630 align:start position:0%
to try out it it's certainly possible
hopefully<00:17:10.480><c> the</c><00:17:10.870><c> next</c><00:17:11.140><c> release</c><00:17:11.410><c> we</c><00:17:12.220><c> will</c><00:17:12.370><c> have</c>

00:17:12.630 --> 00:17:12.640 align:start position:0%
hopefully the next release we will have
 

00:17:12.640 --> 00:17:15.480 align:start position:0%
hopefully the next release we will have
a<00:17:12.910><c> new</c><00:17:13.420><c> ABI</c><00:17:13.780><c> decoder</c><00:17:14.260><c> merged</c><00:17:15.070><c> at</c><00:17:15.250><c> the</c><00:17:15.310><c> same</c>

00:17:15.480 --> 00:17:15.490 align:start position:0%
a new ABI decoder merged at the same
 

00:17:15.490 --> 00:17:19.260 align:start position:0%
a new ABI decoder merged at the same
time<00:17:15.760><c> and</c><00:17:16.000><c> that</c><00:17:16.810><c> will</c><00:17:17.020><c> enable</c><00:17:18.030><c> functions</c><00:17:19.030><c> to</c>

00:17:19.260 --> 00:17:19.270 align:start position:0%
time and that will enable functions to
 

00:17:19.270 --> 00:17:21.840 align:start position:0%
time and that will enable functions to
receive<00:17:19.630><c> structs</c><00:17:20.079><c> because</c><00:17:20.770><c> right</c><00:17:21.010><c> now</c><00:17:21.220><c> you</c>

00:17:21.840 --> 00:17:21.850 align:start position:0%
receive structs because right now you
 

00:17:21.850 --> 00:17:23.670 align:start position:0%
receive structs because right now you
can<00:17:22.060><c> send</c><00:17:22.390><c> structs</c><00:17:22.870><c> but</c><00:17:23.020><c> you</c><00:17:23.140><c> cannot</c><00:17:23.320><c> receive</c>

00:17:23.670 --> 00:17:23.680 align:start position:0%
can send structs but you cannot receive
 

00:17:23.680 --> 00:17:26.699 align:start position:0%
can send structs but you cannot receive
structs<00:17:24.160><c> and</c><00:17:24.660><c> then</c><00:17:25.660><c> hopefully</c><00:17:25.839><c> to</c><00:17:26.260><c> releases</c>

00:17:26.699 --> 00:17:26.709 align:start position:0%
structs and then hopefully to releases
 

00:17:26.709 --> 00:17:30.570 align:start position:0%
structs and then hopefully to releases
from<00:17:26.920><c> now</c><00:17:27.070><c> we</c><00:17:27.880><c> will</c><00:17:28.000><c> have</c><00:17:28.270><c> a</c><00:17:28.860><c> first</c><00:17:29.860><c> version</c><00:17:30.400><c> of</c>

00:17:30.570 --> 00:17:30.580 align:start position:0%
from now we will have a first version of
 

00:17:30.580 --> 00:17:33.660 align:start position:0%
from now we will have a first version of
a<00:17:30.640><c> solidity</c><00:17:31.180><c> to</c><00:17:31.510><c> julia</c><00:17:32.050><c> compiler</c><00:17:32.500><c> as</c><00:17:33.250><c> part</c><00:17:33.550><c> of</c>

00:17:33.660 --> 00:17:33.670 align:start position:0%
a solidity to julia compiler as part of
 

00:17:33.670 --> 00:17:37.690 align:start position:0%
a solidity to julia compiler as part of
solidity<00:17:34.300><c> and</c><00:17:34.600><c> then</c><00:17:35.410><c> in</c><00:17:35.530><c> the</c><00:17:35.590><c> future</c><00:17:35.710><c> he</c><00:17:36.640><c> was</c>

00:17:37.690 --> 00:17:37.700 align:start position:0%
solidity and then in the future he was
 

00:17:37.700 --> 00:17:40.790 align:start position:0%
solidity and then in the future he was
so<00:17:38.700><c> it</c><00:17:38.790><c> can</c><00:17:38.910><c> be</c><00:17:39.000><c> already</c><00:17:39.420><c> tried</c><00:17:40.200><c> out</c><00:17:40.230><c> if</c><00:17:40.620><c> you</c>

00:17:40.790 --> 00:17:40.800 align:start position:0%
so it can be already tried out if you
 

00:17:40.800 --> 00:17:43.160 align:start position:0%
so it can be already tried out if you
dare<00:17:41.040><c> those</c><00:17:41.730><c> are</c><00:17:41.880><c> the</c><00:17:41.940><c> command-line</c><00:17:42.270><c> options</c>

00:17:43.160 --> 00:17:43.170 align:start position:0%
dare those are the command-line options
 

00:17:43.170 --> 00:17:46.550 align:start position:0%
dare those are the command-line options
to<00:17:44.040><c> use</c><00:17:44.280><c> the</c><00:17:44.520><c> solidity</c><00:17:44.850><c> compiler</c><00:17:45.390><c> to</c><00:17:45.810><c> compile</c>

00:17:46.550 --> 00:17:46.560 align:start position:0%
to use the solidity compiler to compile
 

00:17:46.560 --> 00:17:48.560 align:start position:0%
to use the solidity compiler to compile
assembly<00:17:46.950><c> and</c><00:17:47.700><c> you</c><00:17:48.000><c> can</c><00:17:48.120><c> also</c><00:17:48.270><c> switch</c><00:17:48.510><c> to</c>

00:17:48.560 --> 00:17:48.570 align:start position:0%
assembly and you can also switch to
 

00:17:48.570 --> 00:17:49.490 align:start position:0%
assembly and you can also switch to
julia<00:17:49.020><c> mode</c>

00:17:49.490 --> 00:17:49.500 align:start position:0%
julia mode
 

00:17:49.500 --> 00:17:52.810 align:start position:0%
julia mode
the<00:17:49.950><c> only</c><00:17:50.100><c> difference</c><00:17:50.490><c> there</c><00:17:50.670><c> is</c><00:17:50.910><c> using</c><00:17:51.840><c> types</c>

00:17:52.810 --> 00:17:52.820 align:start position:0%
the only difference there is using types
 

00:17:52.820 --> 00:17:56.780 align:start position:0%
the only difference there is using types
at<00:17:53.820><c> the</c><00:17:53.970><c> last</c><00:17:54.120><c> line</c><00:17:54.300><c> is</c><00:17:54.600><c> changing</c><00:17:55.580><c> the</c><00:17:56.580><c> output</c>

00:17:56.780 --> 00:17:56.790 align:start position:0%
at the last line is changing the output
 

00:17:56.790 --> 00:18:01.460 align:start position:0%
at the last line is changing the output
machine<00:17:59.090><c> if</c><00:18:00.090><c> you're</c><00:18:00.450><c> interested</c><00:18:00.900><c> in</c><00:18:00.990><c> Julia</c><00:18:01.260><c> or</c>

00:18:01.460 --> 00:18:01.470 align:start position:0%
machine if you're interested in Julia or
 

00:18:01.470 --> 00:18:03.800 align:start position:0%
machine if you're interested in Julia or
solidity<00:18:02.070><c> development</c><00:18:02.730><c> and</c><00:18:02.970><c> you</c><00:18:03.540><c> can</c><00:18:03.660><c> join</c>

00:18:03.800 --> 00:18:03.810 align:start position:0%
solidity development and you can join
 

00:18:03.810 --> 00:18:07.910 align:start position:0%
solidity development and you can join
the<00:18:03.990><c> solidity</c><00:18:04.410><c> -</c><00:18:04.890><c> dev</c><00:18:05.490><c> channel</c><00:18:06.060><c> on</c><00:18:06.300><c> Gator</c><00:18:07.140><c> or</c>

00:18:07.910 --> 00:18:07.920 align:start position:0%
the solidity - dev channel on Gator or
 

00:18:07.920 --> 00:18:09.260 align:start position:0%
the solidity - dev channel on Gator or
you<00:18:08.070><c> can</c><00:18:08.220><c> just</c><00:18:08.400><c> talk</c><00:18:08.550><c> to</c><00:18:08.580><c> me</c><00:18:08.790><c> directly</c>

00:18:09.260 --> 00:18:09.270 align:start position:0%
you can just talk to me directly
 

00:18:09.270 --> 00:18:16.540 align:start position:0%
you can just talk to me directly
ataxic<00:18:09.960><c> on</c><00:18:10.260><c> Gator</c><00:18:10.740><c> thank</c><00:18:11.580><c> you</c>

00:18:16.540 --> 00:18:16.550 align:start position:0%
 
 

00:18:16.550 --> 00:18:24.130 align:start position:0%
 
[Music]

