WEBVTT
Kind: captions
Language: en

00:00:01.160 --> 00:00:06.690 align:start position:0%
 
[Music]

00:00:06.690 --> 00:00:06.700 align:start position:0%
 
 

00:00:06.700 --> 00:00:10.430 align:start position:0%
 
[Music]

00:00:10.430 --> 00:00:10.440 align:start position:0%
[Music]
 

00:00:10.440 --> 00:00:12.549 align:start position:0%
[Music]
hello<00:00:11.120><c> everyone</c><00:00:11.480><c> who</c><00:00:11.639><c> could</c><00:00:11.840><c> wake</c><00:00:12.080><c> up</c><00:00:12.400><c> thank</c>

00:00:12.549 --> 00:00:12.559 align:start position:0%
hello everyone who could wake up thank
 

00:00:12.559 --> 00:00:14.070 align:start position:0%
hello everyone who could wake up thank
you<00:00:12.639><c> for</c>

00:00:14.070 --> 00:00:14.080 align:start position:0%
you for
 

00:00:14.080 --> 00:00:17.510 align:start position:0%
you for
coming<00:00:15.080><c> uh</c><00:00:15.280><c> this</c><00:00:15.480><c> talk</c><00:00:15.759><c> is</c><00:00:16.039><c> about</c><00:00:16.359><c> EF</c><00:00:17.279><c> uh</c><00:00:17.359><c> we</c>

00:00:17.510 --> 00:00:17.520 align:start position:0%
coming uh this talk is about EF uh we
 

00:00:17.520 --> 00:00:19.790 align:start position:0%
coming uh this talk is about EF uh we
had<00:00:17.640><c> a</c><00:00:17.760><c> very</c><00:00:17.960><c> nice</c><00:00:18.160><c> introduction</c><00:00:18.720><c> thanks</c><00:00:19.039><c> Alex</c>

00:00:19.790 --> 00:00:19.800 align:start position:0%
had a very nice introduction thanks Alex
 

00:00:19.800 --> 00:00:21.590 align:start position:0%
had a very nice introduction thanks Alex
uh<00:00:19.920><c> in</c><00:00:20.039><c> the</c><00:00:20.160><c> previous</c><00:00:20.519><c> presentation</c><00:00:21.080><c> so</c>

00:00:21.590 --> 00:00:21.600 align:start position:0%
uh in the previous presentation so
 

00:00:21.600 --> 00:00:23.189 align:start position:0%
uh in the previous presentation so
hopefully<00:00:22.080><c> you</c><00:00:22.199><c> know</c><00:00:22.439><c> by</c><00:00:22.600><c> now</c><00:00:22.840><c> this</c><00:00:22.920><c> is</c><00:00:23.039><c> a</c>

00:00:23.189 --> 00:00:23.199 align:start position:0%
hopefully you know by now this is a
 

00:00:23.199 --> 00:00:24.230 align:start position:0%
hopefully you know by now this is a
series<00:00:23.480><c> of</c>

00:00:24.230 --> 00:00:24.240 align:start position:0%
series of
 

00:00:24.240 --> 00:00:26.750 align:start position:0%
series of
proposals<00:00:25.240><c> that</c><00:00:25.400><c> aims</c><00:00:25.720><c> at</c><00:00:25.880><c> redesigning</c><00:00:26.560><c> and</c>

00:00:26.750 --> 00:00:26.760 align:start position:0%
proposals that aims at redesigning and
 

00:00:26.760 --> 00:00:30.509 align:start position:0%
proposals that aims at redesigning and
improving<00:00:27.359><c> evm</c><00:00:27.920><c> in</c><00:00:28.160><c> various</c><00:00:28.640><c> ways</c><00:00:29.320><c> and</c><00:00:29.800><c> uh</c><00:00:30.439><c> I</c>

00:00:30.509 --> 00:00:30.519 align:start position:0%
improving evm in various ways and uh I
 

00:00:30.519 --> 00:00:32.870 align:start position:0%
improving evm in various ways and uh I
will<00:00:30.720><c> be</c><00:00:30.880><c> talking</c><00:00:31.240><c> about</c><00:00:31.599><c> one</c><00:00:31.920><c> part</c><00:00:32.160><c> of</c><00:00:32.320><c> it</c><00:00:32.599><c> one</c>

00:00:32.870 --> 00:00:32.880 align:start position:0%
will be talking about one part of it one
 

00:00:32.880 --> 00:00:35.069 align:start position:0%
will be talking about one part of it one
EIP<00:00:33.239><c> 5450</c><00:00:33.879><c> St</c>

00:00:35.069 --> 00:00:35.079 align:start position:0%
EIP 5450 St
 

00:00:35.079 --> 00:00:37.389 align:start position:0%
EIP 5450 St
validation<00:00:36.079><c> stack</c><00:00:36.399><c> validation</c><00:00:36.960><c> is</c><00:00:37.200><c> in</c>

00:00:37.389 --> 00:00:37.399 align:start position:0%
validation stack validation is in
 

00:00:37.399 --> 00:00:39.869 align:start position:0%
validation stack validation is in
general<00:00:38.120><c> one</c><00:00:38.480><c> part</c><00:00:38.680><c> of</c><00:00:38.800><c> a</c><00:00:39.000><c> bigger</c><00:00:39.600><c> code</c>

00:00:39.869 --> 00:00:39.879 align:start position:0%
general one part of a bigger code
 

00:00:39.879 --> 00:00:42.110 align:start position:0%
general one part of a bigger code
validation<00:00:40.559><c> procedure</c><00:00:41.120><c> that</c><00:00:41.320><c> happens</c><00:00:41.760><c> before</c>

00:00:42.110 --> 00:00:42.120 align:start position:0%
validation procedure that happens before
 

00:00:42.120 --> 00:00:45.549 align:start position:0%
validation procedure that happens before
code<00:00:42.399><c> is</c><00:00:42.559><c> being</c><00:00:42.879><c> deployed</c><00:00:43.399><c> on</c><00:00:43.920><c> chain</c><00:00:44.920><c> and</c><00:00:45.320><c> one</c>

00:00:45.549 --> 00:00:45.559 align:start position:0%
code is being deployed on chain and one
 

00:00:45.559 --> 00:00:48.229 align:start position:0%
code is being deployed on chain and one
of<00:00:45.760><c> the</c><00:00:46.079><c> leading</c><00:00:46.600><c> principles</c><00:00:47.440><c> and</c><00:00:47.680><c> main</c><00:00:47.920><c> goals</c>

00:00:48.229 --> 00:00:48.239 align:start position:0%
of the leading principles and main goals
 

00:00:48.239 --> 00:00:50.869 align:start position:0%
of the leading principles and main goals
of<00:00:48.399><c> it</c><00:00:48.719><c> is</c><00:00:49.360><c> uh</c><00:00:49.520><c> to</c><00:00:49.800><c> get</c><00:00:50.000><c> rid</c><00:00:50.239><c> of</c><00:00:50.440><c> repeated</c>

00:00:50.869 --> 00:00:50.879 align:start position:0%
of it is uh to get rid of repeated
 

00:00:50.879 --> 00:00:53.590 align:start position:0%
of it is uh to get rid of repeated
checks<00:00:51.480><c> during</c><00:00:51.879><c> executing</c><00:00:52.359><c> the</c><00:00:52.520><c> same</c><00:00:52.760><c> code</c>

00:00:53.590 --> 00:00:53.600 align:start position:0%
checks during executing the same code
 

00:00:53.600 --> 00:00:56.029 align:start position:0%
checks during executing the same code
and<00:00:53.760><c> instead</c><00:00:54.320><c> if</c><00:00:54.559><c> we</c><00:00:54.719><c> can</c><00:00:54.879><c> if</c><00:00:55.039><c> we</c><00:00:55.199><c> can</c><00:00:55.640><c> do</c><00:00:55.879><c> the</c>

00:00:56.029 --> 00:00:56.039 align:start position:0%
and instead if we can if we can do the
 

00:00:56.039 --> 00:00:58.189 align:start position:0%
and instead if we can if we can do the
check<00:00:56.320><c> once</c><00:00:56.760><c> before</c><00:00:57.039><c> code</c><00:00:57.280><c> is</c><00:00:57.399><c> being</c><00:00:57.600><c> deployed</c>

00:00:58.189 --> 00:00:58.199 align:start position:0%
check once before code is being deployed
 

00:00:58.199 --> 00:01:01.110 align:start position:0%
check once before code is being deployed
then<00:00:58.399><c> we</c><00:00:58.719><c> do</c><00:00:59.039><c> that</c><00:00:59.440><c> and</c><00:01:00.039><c> then</c><00:01:00.359><c> assume</c><00:01:00.840><c> it</c><00:01:00.960><c> is</c>

00:01:01.110 --> 00:01:01.120 align:start position:0%
then we do that and then assume it is
 

00:01:01.120 --> 00:01:04.990 align:start position:0%
then we do that and then assume it is
satisfied<00:01:02.039><c> during</c><00:01:03.039><c> uh</c><00:01:03.480><c> execution</c><00:01:04.239><c> and</c>

00:01:04.990 --> 00:01:05.000 align:start position:0%
satisfied during uh execution and
 

00:01:05.000 --> 00:01:07.590 align:start position:0%
satisfied during uh execution and
then<00:01:06.000><c> basically</c><00:01:06.439><c> we</c><00:01:06.560><c> can</c><00:01:06.840><c> Adit</c><00:01:07.240><c> the</c><00:01:07.400><c> same</c>

00:01:07.590 --> 00:01:07.600 align:start position:0%
then basically we can Adit the same
 

00:01:07.600 --> 00:01:10.590 align:start position:0%
then basically we can Adit the same
checks<00:01:08.320><c> uh</c><00:01:08.680><c> uh</c><00:01:08.799><c> at</c><00:01:09.119><c> runtime</c><00:01:10.119><c> for</c><00:01:10.360><c> stack</c>

00:01:10.590 --> 00:01:10.600 align:start position:0%
checks uh uh at runtime for stack
 

00:01:10.600 --> 00:01:13.469 align:start position:0%
checks uh uh at runtime for stack
validation<00:01:11.040><c> in</c><00:01:11.240><c> particular</c><00:01:12.159><c> this</c><00:01:12.799><c> means</c>

00:01:13.469 --> 00:01:13.479 align:start position:0%
validation in particular this means
 

00:01:13.479 --> 00:01:15.270 align:start position:0%
validation in particular this means
ensuring<00:01:14.040><c> stack</c><00:01:14.360><c> correctness</c><00:01:14.880><c> of</c><00:01:15.040><c> every</c>

00:01:15.270 --> 00:01:15.280 align:start position:0%
ensuring stack correctness of every
 

00:01:15.280 --> 00:01:18.550 align:start position:0%
ensuring stack correctness of every
instruction<00:01:15.759><c> in</c><00:01:15.960><c> the</c><00:01:16.119><c> code</c><00:01:16.640><c> and</c><00:01:17.040><c> in</c><00:01:17.280><c> evm</c><00:01:18.200><c> as</c><00:01:18.400><c> we</c>

00:01:18.550 --> 00:01:18.560 align:start position:0%
instruction in the code and in evm as we
 

00:01:18.560 --> 00:01:20.950 align:start position:0%
instruction in the code and in evm as we
don't<00:01:18.880><c> have</c><00:01:19.520><c> uh</c><00:01:19.840><c> types</c><00:01:20.119><c> of</c><00:01:20.280><c> the</c><00:01:20.439><c> values</c><00:01:20.720><c> on</c>

00:01:20.950 --> 00:01:20.960 align:start position:0%
don't have uh types of the values on
 

00:01:20.960 --> 00:01:23.749 align:start position:0%
don't have uh types of the values on
stack<00:01:21.759><c> this</c><00:01:22.000><c> simply</c><00:01:22.320><c> means</c><00:01:22.840><c> making</c><00:01:23.159><c> sure</c><00:01:23.520><c> that</c>

00:01:23.749 --> 00:01:23.759 align:start position:0%
stack this simply means making sure that
 

00:01:23.759 --> 00:01:25.749 align:start position:0%
stack this simply means making sure that
none<00:01:24.040><c> of</c><00:01:24.159><c> the</c><00:01:24.320><c> instructions</c><00:01:25.040><c> overflow</c><00:01:25.600><c> or</c>

00:01:25.749 --> 00:01:25.759 align:start position:0%
none of the instructions overflow or
 

00:01:25.759 --> 00:01:27.789 align:start position:0%
none of the instructions overflow or
underflow<00:01:26.479><c> the</c>

00:01:27.789 --> 00:01:27.799 align:start position:0%
underflow the
 

00:01:27.799 --> 00:01:30.550 align:start position:0%
underflow the
stack<00:01:28.799><c> and</c><00:01:29.000><c> given</c><00:01:29.280><c> that</c><00:01:29.479><c> we</c><00:01:29.560><c> check</c><00:01:29.759><c> this</c><00:01:30.040><c> once</c>

00:01:30.550 --> 00:01:30.560 align:start position:0%
stack and given that we check this once
 

00:01:30.560 --> 00:01:32.310 align:start position:0%
stack and given that we check this once
uh<00:01:30.680><c> at</c><00:01:30.840><c> validation</c><00:01:31.360><c> then</c><00:01:31.520><c> we</c><00:01:31.640><c> can</c><00:01:31.840><c> omit</c><00:01:32.159><c> these</c>

00:01:32.310 --> 00:01:32.320 align:start position:0%
uh at validation then we can omit these
 

00:01:32.320 --> 00:01:35.389 align:start position:0%
uh at validation then we can omit these
checks<00:01:32.759><c> from</c><00:01:33.079><c> The</c><00:01:33.439><c> Interpreter</c><00:01:33.960><c> Loop</c><00:01:34.920><c> and</c><00:01:35.159><c> one</c>

00:01:35.389 --> 00:01:35.399 align:start position:0%
checks from The Interpreter Loop and one
 

00:01:35.399 --> 00:01:37.310 align:start position:0%
checks from The Interpreter Loop and one
important<00:01:35.840><c> consideration</c><00:01:36.479><c> to</c><00:01:36.720><c> keep</c><00:01:36.880><c> in</c><00:01:37.079><c> mind</c>

00:01:37.310 --> 00:01:37.320 align:start position:0%
important consideration to keep in mind
 

00:01:37.320 --> 00:01:40.109 align:start position:0%
important consideration to keep in mind
when<00:01:37.520><c> designing</c><00:01:38.000><c> St</c><00:01:38.240><c> validation</c><00:01:38.880><c> is</c><00:01:39.799><c> keeping</c>

00:01:40.109 --> 00:01:40.119 align:start position:0%
when designing St validation is keeping
 

00:01:40.119 --> 00:01:42.190 align:start position:0%
when designing St validation is keeping
its<00:01:40.360><c> complexity</c><00:01:40.960><c> linear</c><00:01:41.439><c> in</c><00:01:41.560><c> the</c><00:01:41.680><c> size</c><00:01:41.880><c> of</c><00:01:42.040><c> the</c>

00:01:42.190 --> 00:01:42.200 align:start position:0%
its complexity linear in the size of the
 

00:01:42.200 --> 00:01:45.910 align:start position:0%
its complexity linear in the size of the
code<00:01:43.159><c> uh</c><00:01:43.640><c> this</c><00:01:44.040><c> is</c><00:01:45.000><c> important</c><00:01:45.520><c> because</c><00:01:45.759><c> we</c>

00:01:45.910 --> 00:01:45.920 align:start position:0%
code uh this is important because we
 

00:01:45.920 --> 00:01:48.709 align:start position:0%
code uh this is important because we
cannot<00:01:46.240><c> afford</c><00:01:46.960><c> having</c><00:01:47.240><c> some</c><00:01:47.560><c> Rust</c><00:01:48.079><c> case</c><00:01:48.399><c> bite</c>

00:01:48.709 --> 00:01:48.719 align:start position:0%
cannot afford having some Rust case bite
 

00:01:48.719 --> 00:01:51.429 align:start position:0%
cannot afford having some Rust case bite
codes<00:01:49.680><c> exploding</c><00:01:50.439><c> validation</c><00:01:51.000><c> time</c><00:01:51.240><c> and</c>

00:01:51.429 --> 00:01:51.439 align:start position:0%
codes exploding validation time and
 

00:01:51.439 --> 00:01:53.990 align:start position:0%
codes exploding validation time and
enabling<00:01:51.880><c> dos</c><00:01:52.320><c> attacks</c><00:01:52.960><c> with</c>

00:01:53.990 --> 00:01:54.000 align:start position:0%
enabling dos attacks with
 

00:01:54.000 --> 00:01:57.389 align:start position:0%
enabling dos attacks with
that<00:01:55.000><c> very</c><00:01:55.360><c> high</c><00:01:55.719><c> level</c><00:01:56.079><c> overview</c><00:01:56.520><c> of</c><00:01:56.719><c> how</c><00:01:57.119><c> St</c>

00:01:57.389 --> 00:01:57.399 align:start position:0%
that very high level overview of how St
 

00:01:57.399 --> 00:01:59.510 align:start position:0%
that very high level overview of how St
validation<00:01:57.799><c> would</c><00:01:58.000><c> work</c><00:01:58.399><c> we</c><00:01:59.039><c> go</c><00:01:59.280><c> through</c>

00:01:59.510 --> 00:01:59.520 align:start position:0%
validation would work we go through
 

00:01:59.520 --> 00:02:01.789 align:start position:0%
validation would work we go through
control<00:01:59.920><c> flow</c><00:02:00.119><c> of</c><00:02:00.240><c> the</c><00:02:00.399><c> graph</c><00:02:01.119><c> uh</c><00:02:01.360><c> control</c>

00:02:01.789 --> 00:02:01.799 align:start position:0%
control flow of the graph uh control
 

00:02:01.799 --> 00:02:04.990 align:start position:0%
control flow of the graph uh control
flow<00:02:02.159><c> graph</c><00:02:02.360><c> of</c><00:02:02.479><c> the</c><00:02:02.719><c> code</c><00:02:03.719><c> uh</c><00:02:04.000><c> examine</c><00:02:04.680><c> every</c>

00:02:04.990 --> 00:02:05.000 align:start position:0%
flow graph of the code uh examine every
 

00:02:05.000 --> 00:02:06.990 align:start position:0%
flow graph of the code uh examine every
instruction<00:02:05.439><c> and</c><00:02:05.560><c> see</c><00:02:05.840><c> how</c><00:02:06.000><c> many</c><00:02:06.280><c> values</c><00:02:06.680><c> it</c>

00:02:06.990 --> 00:02:07.000 align:start position:0%
instruction and see how many values it
 

00:02:07.000 --> 00:02:08.830 align:start position:0%
instruction and see how many values it
pushes<00:02:07.320><c> or</c><00:02:07.479><c> Pops</c><00:02:07.759><c> from</c><00:02:07.920><c> the</c><00:02:08.039><c> stack</c><00:02:08.360><c> and</c><00:02:08.599><c> keep</c>

00:02:08.830 --> 00:02:08.840 align:start position:0%
pushes or Pops from the stack and keep
 

00:02:08.840 --> 00:02:10.469 align:start position:0%
pushes or Pops from the stack and keep
track<00:02:09.119><c> of</c><00:02:09.440><c> what</c><00:02:09.560><c> is</c><00:02:09.720><c> the</c><00:02:09.840><c> current</c><00:02:10.119><c> stack</c>

00:02:10.469 --> 00:02:10.479 align:start position:0%
track of what is the current stack
 

00:02:10.479 --> 00:02:13.070 align:start position:0%
track of what is the current stack
height<00:02:10.720><c> if</c><00:02:10.840><c> it</c><00:02:11.039><c> ever</c><00:02:11.920><c> goes</c><00:02:12.239><c> below</c><00:02:12.560><c> zero</c><00:02:12.879><c> we</c>

00:02:13.070 --> 00:02:13.080 align:start position:0%
height if it ever goes below zero we
 

00:02:13.080 --> 00:02:15.949 align:start position:0%
height if it ever goes below zero we
detect<00:02:13.680><c> detect</c><00:02:14.000><c> underflow</c><00:02:14.760><c> if</c><00:02:14.879><c> it</c><00:02:15.040><c> ever</c><00:02:15.319><c> goes</c>

00:02:15.949 --> 00:02:15.959 align:start position:0%
detect detect underflow if it ever goes
 

00:02:15.959 --> 00:02:17.990 align:start position:0%
detect detect underflow if it ever goes
above<00:02:16.360><c> stack</c><00:02:16.680><c> height</c><00:02:16.879><c> limit</c><00:02:17.200><c> we</c><00:02:17.400><c> detect</c>

00:02:17.990 --> 00:02:18.000 align:start position:0%
above stack height limit we detect
 

00:02:18.000 --> 00:02:20.070 align:start position:0%
above stack height limit we detect
overflow<00:02:18.599><c> and</c><00:02:18.800><c> reject</c><00:02:19.160><c> this</c><00:02:19.360><c> entire</c><00:02:19.680><c> code</c><00:02:19.920><c> AS</c>

00:02:20.070 --> 00:02:20.080 align:start position:0%
overflow and reject this entire code AS
 

00:02:20.080 --> 00:02:23.990 align:start position:0%
overflow and reject this entire code AS
invalid<00:02:20.480><c> and</c><00:02:20.599><c> do</c><00:02:20.760><c> not</c><00:02:20.920><c> allow</c><00:02:21.239><c> to</c><00:02:22.120><c> for</c><00:02:22.319><c> it</c><00:02:22.440><c> to</c><00:02:22.560><c> be</c>

00:02:23.990 --> 00:02:24.000 align:start position:0%
invalid and do not allow to for it to be
 

00:02:24.000 --> 00:02:26.949 align:start position:0%
invalid and do not allow to for it to be
deployed<00:02:25.000><c> uh</c><00:02:25.160><c> this</c><00:02:25.519><c> sounds</c><00:02:26.120><c> pretty</c><00:02:26.440><c> simple</c>

00:02:26.949 --> 00:02:26.959 align:start position:0%
deployed uh this sounds pretty simple
 

00:02:26.959 --> 00:02:29.350 align:start position:0%
deployed uh this sounds pretty simple
and<00:02:27.200><c> high</c><00:02:27.400><c> level</c><00:02:27.879><c> and</c><00:02:28.080><c> you</c><00:02:28.239><c> might</c><00:02:28.480><c> wonder</c><00:02:29.200><c> at</c>

00:02:29.350 --> 00:02:29.360 align:start position:0%
and high level and you might wonder at
 

00:02:29.360 --> 00:02:31.470 align:start position:0%
and high level and you might wonder at
this<00:02:29.519><c> point</c><00:02:29.959><c> how</c><00:02:30.160><c> is</c><00:02:30.280><c> this</c><00:02:30.480><c> even</c><00:02:30.879><c> possible</c><00:02:31.239><c> to</c>

00:02:31.470 --> 00:02:31.480 align:start position:0%
this point how is this even possible to
 

00:02:31.480 --> 00:02:33.309 align:start position:0%
this point how is this even possible to
achieve<00:02:31.959><c> without</c><00:02:32.360><c> executing</c><00:02:32.840><c> the</c><00:02:32.959><c> code</c>

00:02:33.309 --> 00:02:33.319 align:start position:0%
achieve without executing the code
 

00:02:33.319 --> 00:02:35.869 align:start position:0%
achieve without executing the code
because<00:02:33.560><c> we</c><00:02:33.680><c> are</c><00:02:33.879><c> used</c><00:02:34.239><c> to</c><00:02:34.640><c> thinking</c><00:02:35.640><c> about</c>

00:02:35.869 --> 00:02:35.879 align:start position:0%
because we are used to thinking about
 

00:02:35.879 --> 00:02:38.869 align:start position:0%
because we are used to thinking about
underflows<00:02:36.440><c> and</c><00:02:36.599><c> overflows</c><00:02:37.319><c> as</c><00:02:38.040><c> depending</c><00:02:38.560><c> on</c>

00:02:38.869 --> 00:02:38.879 align:start position:0%
underflows and overflows as depending on
 

00:02:38.879 --> 00:02:42.509 align:start position:0%
underflows and overflows as depending on
the<00:02:39.640><c> runtime</c><00:02:40.640><c> uh</c><00:02:40.840><c> value</c><00:02:41.200><c> of</c><00:02:41.319><c> the</c><00:02:41.480><c> stack</c><00:02:41.840><c> height</c>

00:02:42.509 --> 00:02:42.519 align:start position:0%
the runtime uh value of the stack height
 

00:02:42.519 --> 00:02:45.270 align:start position:0%
the runtime uh value of the stack height
and<00:02:43.040><c> uh</c><00:02:43.200><c> depending</c><00:02:43.640><c> on</c><00:02:44.000><c> whatever</c><00:02:44.640><c> runtime</c>

00:02:45.270 --> 00:02:45.280 align:start position:0%
and uh depending on whatever runtime
 

00:02:45.280 --> 00:02:47.470 align:start position:0%
and uh depending on whatever runtime
conditions<00:02:45.560><c> on</c><00:02:45.920><c> call</c><00:02:46.200><c> data</c><00:02:46.440><c> or</c><00:02:46.720><c> storage</c><00:02:47.159><c> or</c>

00:02:47.470 --> 00:02:47.480 align:start position:0%
conditions on call data or storage or
 

00:02:47.480 --> 00:02:49.790 align:start position:0%
conditions on call data or storage or
whatever<00:02:48.480><c> I</c><00:02:48.560><c> will</c><00:02:48.720><c> show</c><00:02:48.920><c> you</c><00:02:49.120><c> that</c><00:02:49.319><c> in</c><00:02:49.480><c> fact</c>

00:02:49.790 --> 00:02:49.800 align:start position:0%
whatever I will show you that in fact
 

00:02:49.800 --> 00:02:51.990 align:start position:0%
whatever I will show you that in fact
this<00:02:49.920><c> is</c><00:02:50.239><c> possible</c><00:02:50.720><c> given</c><00:02:50.959><c> that</c><00:02:51.120><c> we</c><00:02:51.360><c> impose</c>

00:02:51.990 --> 00:02:52.000 align:start position:0%
this is possible given that we impose
 

00:02:52.000 --> 00:02:54.309 align:start position:0%
this is possible given that we impose
one<00:02:52.239><c> extra</c><00:02:52.560><c> restriction</c><00:02:53.080><c> on</c><00:02:53.519><c> what</c><00:02:53.680><c> is</c><00:02:53.920><c> allowed</c>

00:02:54.309 --> 00:02:54.319 align:start position:0%
one extra restriction on what is allowed
 

00:02:54.319 --> 00:02:57.630 align:start position:0%
one extra restriction on what is allowed
in<00:02:54.440><c> the</c><00:02:54.959><c> code</c><00:02:55.959><c> uh</c><00:02:56.080><c> so</c><00:02:56.319><c> let's</c><00:02:56.640><c> zoom</c><00:02:56.920><c> in</c><00:02:57.159><c> and</c>

00:02:57.630 --> 00:02:57.640 align:start position:0%
in the code uh so let's zoom in and
 

00:02:57.640 --> 00:03:00.350 align:start position:0%
in the code uh so let's zoom in and
explore<00:02:58.040><c> how</c><00:02:58.280><c> this</c><00:02:58.760><c> would</c><00:02:59.040><c> work</c>

00:03:00.350 --> 00:03:00.360 align:start position:0%
explore how this would work
 

00:03:00.360 --> 00:03:02.830 align:start position:0%
explore how this would work
this<00:03:00.519><c> was</c><00:03:00.800><c> our</c><00:03:01.280><c> initial</c><00:03:01.879><c> approach</c><00:03:02.280><c> to</c><00:03:02.480><c> this</c>

00:03:02.830 --> 00:03:02.840 align:start position:0%
this was our initial approach to this
 

00:03:02.840 --> 00:03:05.949 align:start position:0%
this was our initial approach to this
problem<00:03:03.720><c> um</c><00:03:04.200><c> and</c><00:03:04.760><c> let's</c><00:03:05.000><c> discuss</c><00:03:05.360><c> underflows</c>

00:03:05.949 --> 00:03:05.959 align:start position:0%
problem um and let's discuss underflows
 

00:03:05.959 --> 00:03:07.910 align:start position:0%
problem um and let's discuss underflows
first<00:03:06.319><c> uh</c><00:03:06.440><c> overflows</c><00:03:06.920><c> are</c><00:03:07.080><c> handled</c><00:03:07.599><c> quite</c>

00:03:07.910 --> 00:03:07.920 align:start position:0%
first uh overflows are handled quite
 

00:03:07.920 --> 00:03:10.070 align:start position:0%
first uh overflows are handled quite
differently<00:03:08.319><c> I</c><00:03:08.360><c> will</c><00:03:08.519><c> mention</c><00:03:08.840><c> this</c><00:03:09.040><c> later</c><00:03:09.879><c> so</c>

00:03:10.070 --> 00:03:10.080 align:start position:0%
differently I will mention this later so
 

00:03:10.080 --> 00:03:12.270 align:start position:0%
differently I will mention this later so
every<00:03:10.319><c> section</c><00:03:10.680><c> is</c><00:03:11.040><c> validated</c><00:03:11.640><c> independently</c>

00:03:12.270 --> 00:03:12.280 align:start position:0%
every section is validated independently
 

00:03:12.280 --> 00:03:14.750 align:start position:0%
every section is validated independently
one<00:03:12.480><c> section</c><00:03:12.720><c> at</c><00:03:12.840><c> a</c><00:03:13.000><c> time</c><00:03:13.799><c> uh</c><00:03:13.920><c> we</c><00:03:14.159><c> Traverse</c><00:03:14.640><c> the</c>

00:03:14.750 --> 00:03:14.760 align:start position:0%
one section at a time uh we Traverse the
 

00:03:14.760 --> 00:03:17.589 align:start position:0%
one section at a time uh we Traverse the
control<00:03:15.080><c> flow</c><00:03:15.400><c> graph</c><00:03:15.680><c> of</c><00:03:15.959><c> the</c><00:03:16.599><c> uh</c><00:03:16.799><c> code</c><00:03:17.360><c> in</c><00:03:17.480><c> a</c>

00:03:17.589 --> 00:03:17.599 align:start position:0%
control flow graph of the uh code in a
 

00:03:17.599 --> 00:03:19.110 align:start position:0%
control flow graph of the uh code in a
breadth<00:03:17.920><c> resarch</c><00:03:18.280><c> or</c><00:03:18.440><c> depth</c><00:03:18.640><c> res</c><00:03:18.840><c> search</c>

00:03:19.110 --> 00:03:19.120 align:start position:0%
breadth resarch or depth res search
 

00:03:19.120 --> 00:03:21.910 align:start position:0%
breadth resarch or depth res search
manner<00:03:19.760><c> meaning</c><00:03:20.120><c> we</c><00:03:20.280><c> follow</c><00:03:20.640><c> every</c><00:03:20.920><c> jump</c><00:03:21.760><c> uh</c>

00:03:21.910 --> 00:03:21.920 align:start position:0%
manner meaning we follow every jump uh
 

00:03:21.920 --> 00:03:23.509 align:start position:0%
manner meaning we follow every jump uh
if<00:03:22.000><c> it's</c><00:03:22.159><c> a</c><00:03:22.440><c> conditional</c><00:03:22.720><c> jump</c><00:03:23.000><c> we</c><00:03:23.159><c> follow</c>

00:03:23.509 --> 00:03:23.519 align:start position:0%
if it's a conditional jump we follow
 

00:03:23.519 --> 00:03:26.589 align:start position:0%
if it's a conditional jump we follow
both<00:03:23.799><c> branches</c><00:03:24.200><c> of</c><00:03:24.319><c> the</c><00:03:24.959><c> jump</c><00:03:25.959><c> uh</c><00:03:26.159><c> we</c><00:03:26.400><c> keep</c>

00:03:26.589 --> 00:03:26.599 align:start position:0%
both branches of the jump uh we keep
 

00:03:26.599 --> 00:03:28.110 align:start position:0%
both branches of the jump uh we keep
track<00:03:26.879><c> of</c><00:03:27.120><c> what</c><00:03:27.239><c> is</c><00:03:27.360><c> the</c><00:03:27.560><c> current</c><00:03:27.799><c> stack</c>

00:03:28.110 --> 00:03:28.120 align:start position:0%
track of what is the current stack
 

00:03:28.120 --> 00:03:29.470 align:start position:0%
track of what is the current stack
height<00:03:28.280><c> for</c><00:03:28.400><c> every</c><00:03:28.599><c> instruction</c><00:03:29.000><c> and</c><00:03:29.159><c> record</c>

00:03:29.470 --> 00:03:29.480 align:start position:0%
height for every instruction and record
 

00:03:29.480 --> 00:03:30.589 align:start position:0%
height for every instruction and record
it

00:03:30.589 --> 00:03:30.599 align:start position:0%
it
 

00:03:30.599 --> 00:03:32.589 align:start position:0%
it
uh<00:03:30.799><c> if</c><00:03:30.959><c> it</c><00:03:31.200><c> goes</c><00:03:31.480><c> below</c><00:03:31.840><c> zero</c><00:03:32.120><c> we</c><00:03:32.280><c> detect</c>

00:03:32.589 --> 00:03:32.599 align:start position:0%
uh if it goes below zero we detect
 

00:03:32.599 --> 00:03:34.789 align:start position:0%
uh if it goes below zero we detect
underflow<00:03:33.120><c> and</c><00:03:33.280><c> reject</c><00:03:33.640><c> this</c><00:03:33.799><c> code</c><00:03:34.000><c> AS</c>

00:03:34.789 --> 00:03:34.799 align:start position:0%
underflow and reject this code AS
 

00:03:34.799 --> 00:03:37.229 align:start position:0%
underflow and reject this code AS
invalid<00:03:35.799><c> and</c><00:03:36.120><c> one</c><00:03:36.360><c> extra</c><00:03:36.680><c> restriction</c><00:03:37.080><c> that</c>

00:03:37.229 --> 00:03:37.239 align:start position:0%
invalid and one extra restriction that
 

00:03:37.239 --> 00:03:40.869 align:start position:0%
invalid and one extra restriction that
makes<00:03:37.400><c> it</c><00:03:37.560><c> all</c><00:03:37.799><c> possible</c><00:03:38.280><c> is</c><00:03:39.040><c> the</c><00:03:39.480><c> rule</c><00:03:40.480><c> if</c><00:03:40.640><c> we</c>

00:03:40.869 --> 00:03:40.879 align:start position:0%
makes it all possible is the rule if we
 

00:03:40.879 --> 00:03:43.750 align:start position:0%
makes it all possible is the rule if we
ever<00:03:41.720><c> uh</c><00:03:41.920><c> encounter</c><00:03:42.439><c> an</c><00:03:42.599><c> instruction</c><00:03:43.120><c> that</c>

00:03:43.750 --> 00:03:43.760 align:start position:0%
ever uh encounter an instruction that
 

00:03:43.760 --> 00:03:45.869 align:start position:0%
ever uh encounter an instruction that
during<00:03:44.040><c> out</c><00:03:44.280><c> reversal</c><00:03:44.799><c> that</c><00:03:45.120><c> was</c><00:03:45.400><c> already</c>

00:03:45.869 --> 00:03:45.879 align:start position:0%
during out reversal that was already
 

00:03:45.879 --> 00:03:48.990 align:start position:0%
during out reversal that was already
visited<00:03:46.879><c> before</c><00:03:47.879><c> uh</c><00:03:48.040><c> it</c><00:03:48.200><c> means</c><00:03:48.599><c> that</c><00:03:48.799><c> this</c>

00:03:48.990 --> 00:03:49.000 align:start position:0%
visited before uh it means that this
 

00:03:49.000 --> 00:03:51.110 align:start position:0%
visited before uh it means that this
instruction<00:03:49.519><c> may</c><00:03:49.680><c> be</c><00:03:49.840><c> reached</c><00:03:50.319><c> via</c><00:03:50.599><c> multiple</c>

00:03:51.110 --> 00:03:51.120 align:start position:0%
instruction may be reached via multiple
 

00:03:51.120 --> 00:03:53.990 align:start position:0%
instruction may be reached via multiple
possible<00:03:51.480><c> code</c><00:03:51.840><c> paths</c><00:03:52.120><c> during</c><00:03:52.480><c> execution</c><00:03:53.439><c> and</c>

00:03:53.990 --> 00:03:54.000 align:start position:0%
possible code paths during execution and
 

00:03:54.000 --> 00:03:56.229 align:start position:0%
possible code paths during execution and
uh<00:03:54.680><c> in</c><00:03:54.879><c> this</c><00:03:55.120><c> case</c><00:03:55.319><c> we</c><00:03:55.519><c> require</c><00:03:55.920><c> that</c><00:03:56.079><c> the</c>

00:03:56.229 --> 00:03:56.239 align:start position:0%
uh in this case we require that the
 

00:03:56.239 --> 00:03:58.110 align:start position:0%
uh in this case we require that the
stack<00:03:56.519><c> height</c><00:03:56.760><c> at</c><00:03:56.959><c> this</c><00:03:57.239><c> instruction</c><00:03:57.840><c> is</c>

00:03:58.110 --> 00:03:58.120 align:start position:0%
stack height at this instruction is
 

00:03:58.120 --> 00:04:00.630 align:start position:0%
stack height at this instruction is
equal<00:03:58.480><c> for</c><00:03:58.720><c> all</c><00:03:58.920><c> possible</c><00:03:59.280><c> code</c><00:03:59.560><c> P</c><00:03:59.959><c> leading</c><00:04:00.280><c> to</c>

00:04:00.630 --> 00:04:00.640 align:start position:0%
equal for all possible code P leading to
 

00:04:00.640 --> 00:04:03.910 align:start position:0%
equal for all possible code P leading to
it<00:04:01.640><c> so</c><00:04:01.879><c> this</c><00:04:02.000><c> is</c><00:04:02.159><c> something</c><00:04:02.640><c> new</c><00:04:03.079><c> comparing</c><00:04:03.599><c> to</c>

00:04:03.910 --> 00:04:03.920 align:start position:0%
it so this is something new comparing to
 

00:04:03.920 --> 00:04:07.270 align:start position:0%
it so this is something new comparing to
current<00:04:04.280><c> evm</c><00:04:04.840><c> so</c><00:04:05.280><c> this</c><00:04:06.239><c> makes</c><00:04:06.640><c> some</c><00:04:06.879><c> of</c><00:04:07.040><c> the</c>

00:04:07.270 --> 00:04:07.280 align:start position:0%
current evm so this makes some of the
 

00:04:07.280 --> 00:04:09.270 align:start position:0%
current evm so this makes some of the
patterns<00:04:07.799><c> that</c><00:04:07.959><c> were</c><00:04:08.280><c> possible</c><00:04:08.799><c> in</c><00:04:09.000><c> current</c>

00:04:09.270 --> 00:04:09.280 align:start position:0%
patterns that were possible in current
 

00:04:09.280 --> 00:04:12.830 align:start position:0%
patterns that were possible in current
evm<00:04:09.920><c> uh</c><00:04:10.040><c> invalid</c><00:04:10.640><c> now</c><00:04:10.920><c> in</c><00:04:11.439><c> eof</c><00:04:12.439><c> uh</c><00:04:12.560><c> as</c><00:04:12.640><c> a</c>

00:04:12.830 --> 00:04:12.840 align:start position:0%
evm uh invalid now in eof uh as a
 

00:04:12.840 --> 00:04:13.789 align:start position:0%
evm uh invalid now in eof uh as a
practical

00:04:13.789 --> 00:04:13.799 align:start position:0%
practical
 

00:04:13.799 --> 00:04:16.830 align:start position:0%
practical
example<00:04:14.799><c> for</c><00:04:15.439><c> if</c><00:04:15.760><c> then</c><00:04:15.920><c> else</c><00:04:16.239><c> statement</c><00:04:16.720><c> you</c>

00:04:16.830 --> 00:04:16.840 align:start position:0%
example for if then else statement you
 

00:04:16.840 --> 00:04:18.629 align:start position:0%
example for if then else statement you
would<00:04:17.000><c> be</c><00:04:17.199><c> required</c><00:04:17.560><c> to</c><00:04:17.759><c> have</c><00:04:17.959><c> equal</c><00:04:18.239><c> stack</c>

00:04:18.629 --> 00:04:18.639 align:start position:0%
would be required to have equal stack
 

00:04:18.639 --> 00:04:20.590 align:start position:0%
would be required to have equal stack
height<00:04:19.079><c> at</c><00:04:19.199><c> the</c><00:04:19.320><c> end</c><00:04:19.519><c> of</c><00:04:19.680><c> the</c><00:04:19.959><c> than</c><00:04:20.160><c> and</c><00:04:20.320><c> else</c>

00:04:20.590 --> 00:04:20.600 align:start position:0%
height at the end of the than and else
 

00:04:20.600 --> 00:04:24.270 align:start position:0%
height at the end of the than and else
branches<00:04:21.160><c> for</c><00:04:21.440><c> example</c><00:04:22.440><c> or</c><00:04:22.800><c> for</c><00:04:23.280><c> Loops</c><00:04:24.040><c> for</c>

00:04:24.270 --> 00:04:24.280 align:start position:0%
branches for example or for Loops for
 

00:04:24.280 --> 00:04:26.749 align:start position:0%
branches for example or for Loops for
example<00:04:24.840><c> the</c><00:04:24.960><c> loop</c><00:04:25.360><c> body</c><00:04:25.800><c> is</c><00:04:25.960><c> not</c><00:04:26.199><c> allowed</c><00:04:26.560><c> to</c>

00:04:26.749 --> 00:04:26.759 align:start position:0%
example the loop body is not allowed to
 

00:04:26.759 --> 00:04:29.310 align:start position:0%
example the loop body is not allowed to
grow<00:04:27.000><c> or</c><00:04:27.160><c> Shrink</c><00:04:27.800><c> stack</c><00:04:28.800><c> these</c><00:04:28.960><c> are</c><00:04:29.120><c> pretty</c>

00:04:29.310 --> 00:04:29.320 align:start position:0%
grow or Shrink stack these are pretty
 

00:04:29.320 --> 00:04:31.550 align:start position:0%
grow or Shrink stack these are pretty
reasonable<00:04:29.840><c> restrictions</c><00:04:30.280><c> to</c><00:04:30.520><c> have</c><00:04:31.240><c> other</c>

00:04:31.550 --> 00:04:31.560 align:start position:0%
reasonable restrictions to have other
 

00:04:31.560 --> 00:04:34.150 align:start position:0%
reasonable restrictions to have other
vmss<00:04:32.160><c> also</c><00:04:32.560><c> have</c><00:04:32.759><c> similar</c><00:04:33.080><c> rules</c><00:04:33.440><c> like</c><00:04:33.639><c> jvm</c>

00:04:34.150 --> 00:04:34.160 align:start position:0%
vmss also have similar rules like jvm
 

00:04:34.160 --> 00:04:35.629 align:start position:0%
vmss also have similar rules like jvm
and<00:04:34.400><c> web</c>

00:04:35.629 --> 00:04:35.639 align:start position:0%
and web
 

00:04:35.639 --> 00:04:38.110 align:start position:0%
and web
assembly<00:04:36.639><c> and</c><00:04:37.000><c> uh</c><00:04:37.120><c> thanks</c><00:04:37.320><c> to</c><00:04:37.479><c> this</c><00:04:37.680><c> rule</c><00:04:37.919><c> we</c>

00:04:38.110 --> 00:04:38.120 align:start position:0%
assembly and uh thanks to this rule we
 

00:04:38.120 --> 00:04:40.110 align:start position:0%
assembly and uh thanks to this rule we
just<00:04:38.440><c> when</c><00:04:38.639><c> we</c><00:04:39.080><c> get</c><00:04:39.240><c> to</c><00:04:39.400><c> the</c><00:04:39.560><c> branch</c><00:04:39.880><c> that</c><00:04:40.000><c> we</c>

00:04:40.110 --> 00:04:40.120 align:start position:0%
just when we get to the branch that we
 

00:04:40.120 --> 00:04:42.029 align:start position:0%
just when we get to the branch that we
have<00:04:40.280><c> already</c><00:04:40.479><c> seen</c><00:04:40.800><c> we</c><00:04:40.960><c> just</c><00:04:41.400><c> check</c><00:04:41.680><c> this</c>

00:04:42.029 --> 00:04:42.039 align:start position:0%
have already seen we just check this
 

00:04:42.039 --> 00:04:44.110 align:start position:0%
have already seen we just check this
condition<00:04:42.360><c> and</c><00:04:42.560><c> do</c><00:04:42.720><c> not</c><00:04:43.160><c> revalidate</c><00:04:43.800><c> the</c><00:04:43.919><c> same</c>

00:04:44.110 --> 00:04:44.120 align:start position:0%
condition and do not revalidate the same
 

00:04:44.120 --> 00:04:46.150 align:start position:0%
condition and do not revalidate the same
Branch<00:04:44.560><c> so</c><00:04:44.800><c> in</c><00:04:44.919><c> the</c><00:04:45.039><c> end</c><00:04:45.320><c> every</c><00:04:45.680><c> branch</c><00:04:46.000><c> is</c>

00:04:46.150 --> 00:04:46.160 align:start position:0%
Branch so in the end every branch is
 

00:04:46.160 --> 00:04:48.390 align:start position:0%
Branch so in the end every branch is
validated<00:04:46.759><c> exactly</c><00:04:47.160><c> once</c><00:04:47.520><c> every</c><00:04:47.759><c> instruction</c>

00:04:48.390 --> 00:04:48.400 align:start position:0%
validated exactly once every instruction
 

00:04:48.400 --> 00:04:51.510 align:start position:0%
validated exactly once every instruction
is<00:04:48.800><c> visited</c><00:04:49.600><c> exactly</c><00:04:50.039><c> once</c><00:04:50.400><c> so</c><00:04:50.720><c> complexity</c><00:04:51.320><c> is</c>

00:04:51.510 --> 00:04:51.520 align:start position:0%
is visited exactly once so complexity is
 

00:04:51.520 --> 00:04:53.550 align:start position:0%
is visited exactly once so complexity is
linear<00:04:52.000><c> for</c><00:04:52.240><c> this</c><00:04:52.400><c> algorithm</c><00:04:52.960><c> which</c><00:04:53.080><c> is</c><00:04:53.400><c> what</c>

00:04:53.550 --> 00:04:53.560 align:start position:0%
linear for this algorithm which is what
 

00:04:53.560 --> 00:04:57.110 align:start position:0%
linear for this algorithm which is what
we<00:04:53.840><c> desired</c><00:04:54.320><c> so</c><00:04:54.520><c> this</c><00:04:54.639><c> is</c><00:04:54.840><c> great</c><00:04:55.840><c> and</c><00:04:56.080><c> one</c><00:04:56.880><c> uh</c>

00:04:57.110 --> 00:04:57.120 align:start position:0%
we desired so this is great and one uh
 

00:04:57.120 --> 00:05:00.070 align:start position:0%
we desired so this is great and one uh
extra<00:04:57.479><c> rule</c><00:04:57.759><c> that</c><00:04:57.919><c> we</c><00:04:58.120><c> have</c><00:04:58.759><c> uh</c><00:04:58.960><c> if</c><00:04:59.240><c> after</c><00:04:59.880><c> the</c>

00:05:00.070 --> 00:05:00.080 align:start position:0%
extra rule that we have uh if after the
 

00:05:00.080 --> 00:05:01.710 align:start position:0%
extra rule that we have uh if after the
traval<00:05:00.560><c> is</c><00:05:00.680><c> finished</c><00:05:01.240><c> some</c><00:05:01.400><c> of</c><00:05:01.560><c> the</c>

00:05:01.710 --> 00:05:01.720 align:start position:0%
traval is finished some of the
 

00:05:01.720 --> 00:05:04.110 align:start position:0%
traval is finished some of the
instructions<00:05:02.280><c> are</c><00:05:02.520><c> not</c><00:05:02.919><c> visited</c><00:05:03.759><c> it</c><00:05:03.880><c> means</c>

00:05:04.110 --> 00:05:04.120 align:start position:0%
instructions are not visited it means
 

00:05:04.120 --> 00:05:06.469 align:start position:0%
instructions are not visited it means
they<00:05:04.240><c> are</c><00:05:04.400><c> never</c><00:05:04.639><c> going</c><00:05:04.840><c> to</c><00:05:04.960><c> be</c><00:05:05.120><c> reached</c><00:05:05.520><c> in</c><00:05:06.240><c> uh</c>

00:05:06.469 --> 00:05:06.479 align:start position:0%
they are never going to be reached in uh
 

00:05:06.479 --> 00:05:08.950 align:start position:0%
they are never going to be reached in uh
execution<00:05:07.360><c> and</c><00:05:07.800><c> we</c><00:05:07.919><c> do</c><00:05:08.080><c> not</c><00:05:08.240><c> allow</c><00:05:08.520><c> this</c><00:05:08.720><c> we</c><00:05:08.800><c> do</c>

00:05:08.950 --> 00:05:08.960 align:start position:0%
execution and we do not allow this we do
 

00:05:08.960 --> 00:05:10.430 align:start position:0%
execution and we do not allow this we do
not<00:05:09.120><c> allow</c><00:05:09.400><c> unreachable</c><00:05:09.960><c> code</c><00:05:10.199><c> to</c><00:05:10.280><c> be</c>

00:05:10.430 --> 00:05:10.440 align:start position:0%
not allow unreachable code to be
 

00:05:10.440 --> 00:05:12.430 align:start position:0%
not allow unreachable code to be
deployed<00:05:10.919><c> and</c><00:05:11.080><c> reject</c><00:05:11.440><c> an</c><00:05:11.639><c> entire</c><00:05:12.000><c> bite</c><00:05:12.240><c> code</c>

00:05:12.430 --> 00:05:12.440 align:start position:0%
deployed and reject an entire bite code
 

00:05:12.440 --> 00:05:13.390 align:start position:0%
deployed and reject an entire bite code
AS

00:05:13.390 --> 00:05:13.400 align:start position:0%
AS
 

00:05:13.400 --> 00:05:15.710 align:start position:0%
AS
invalid<00:05:14.400><c> I'll</c><00:05:14.600><c> show</c><00:05:14.800><c> an</c><00:05:14.960><c> example</c><00:05:15.320><c> now</c><00:05:15.479><c> how</c>

00:05:15.710 --> 00:05:15.720 align:start position:0%
invalid I'll show an example now how
 

00:05:15.720 --> 00:05:19.270 align:start position:0%
invalid I'll show an example now how
this<00:05:15.880><c> would</c><00:05:16.440><c> work</c><00:05:17.440><c> here's</c><00:05:17.639><c> a</c><00:05:17.759><c> simple</c><00:05:18.160><c> code</c><00:05:19.160><c> uh</c>

00:05:19.270 --> 00:05:19.280 align:start position:0%
this would work here's a simple code uh
 

00:05:19.280 --> 00:05:20.950 align:start position:0%
this would work here's a simple code uh
we'll<00:05:19.479><c> need</c><00:05:19.680><c> an</c><00:05:19.840><c> array</c><00:05:20.160><c> of</c><00:05:20.280><c> Stack</c><00:05:20.600><c> Heights</c><00:05:20.800><c> for</c>

00:05:20.950 --> 00:05:20.960 align:start position:0%
we'll need an array of Stack Heights for
 

00:05:20.960 --> 00:05:23.790 align:start position:0%
we'll need an array of Stack Heights for
every<00:05:21.199><c> instruction</c><00:05:22.199><c> and</c><00:05:22.520><c> work</c><00:05:22.880><c> list</c><00:05:23.199><c> here</c><00:05:23.479><c> is</c>

00:05:23.790 --> 00:05:23.800 align:start position:0%
every instruction and work list here is
 

00:05:23.800 --> 00:05:25.830 align:start position:0%
every instruction and work list here is
a<00:05:24.240><c> q</c><00:05:24.520><c> like</c><00:05:24.720><c> data</c><00:05:24.919><c> structure</c><00:05:25.240><c> that</c><00:05:25.360><c> keeps</c><00:05:25.600><c> track</c>

00:05:25.830 --> 00:05:25.840 align:start position:0%
a q like data structure that keeps track
 

00:05:25.840 --> 00:05:28.390 align:start position:0%
a q like data structure that keeps track
of<00:05:26.080><c> which</c><00:05:26.440><c> branches</c><00:05:27.000><c> we</c><00:05:27.720><c> have</c><00:05:28.000><c> yet</c><00:05:28.240><c> to</c>

00:05:28.390 --> 00:05:28.400 align:start position:0%
of which branches we have yet to
 

00:05:28.400 --> 00:05:30.749 align:start position:0%
of which branches we have yet to
validate<00:05:28.919><c> so</c><00:05:29.080><c> we</c><00:05:29.199><c> start</c><00:05:29.440><c> with</c><00:05:30.039><c> first</c><00:05:30.319><c> Branch</c>

00:05:30.749 --> 00:05:30.759 align:start position:0%
validate so we start with first Branch
 

00:05:30.759 --> 00:05:33.870 align:start position:0%
validate so we start with first Branch
at<00:05:31.039><c> offset</c><00:05:31.560><c> zero</c><00:05:32.560><c> uh</c><00:05:32.720><c> push</c><00:05:33.000><c> instruction</c><00:05:33.560><c> would</c>

00:05:33.870 --> 00:05:33.880 align:start position:0%
at offset zero uh push instruction would
 

00:05:33.880 --> 00:05:36.749 align:start position:0%
at offset zero uh push instruction would
add<00:05:34.360><c> one</c><00:05:35.280><c> value</c><00:05:35.520><c> on</c><00:05:35.639><c> the</c><00:05:35.759><c> stack</c><00:05:36.240><c> uh</c><00:05:36.319><c> then</c><00:05:36.520><c> call</c>

00:05:36.749 --> 00:05:36.759 align:start position:0%
add one value on the stack uh then call
 

00:05:36.759 --> 00:05:38.510 align:start position:0%
add one value on the stack uh then call
data<00:05:37.000><c> load</c><00:05:37.240><c> doesn't</c><00:05:37.520><c> change</c><00:05:37.840><c> the</c><00:05:37.919><c> St</c><00:05:38.199><c> height</c>

00:05:38.510 --> 00:05:38.520 align:start position:0%
data load doesn't change the St height
 

00:05:38.520 --> 00:05:40.790 align:start position:0%
data load doesn't change the St height
then<00:05:38.759><c> this</c><00:05:39.120><c> conditional</c><00:05:39.360><c> jump</c><00:05:39.800><c> instruction</c>

00:05:40.790 --> 00:05:40.800 align:start position:0%
then this conditional jump instruction
 

00:05:40.800 --> 00:05:44.189 align:start position:0%
then this conditional jump instruction
has<00:05:41.080><c> two</c><00:05:41.479><c> possible</c><00:05:42.560><c> successors</c><00:05:43.560><c> at</c><00:05:43.759><c> offsets</c>

00:05:44.189 --> 00:05:44.199 align:start position:0%
has two possible successors at offsets
 

00:05:44.199 --> 00:05:46.270 align:start position:0%
has two possible successors at offsets
10<00:05:44.360><c> and</c><00:05:44.560><c> five</c><00:05:44.880><c> we</c><00:05:45.120><c> add</c><00:05:45.360><c> them</c><00:05:45.520><c> both</c><00:05:45.919><c> into</c><00:05:46.160><c> the</c>

00:05:46.270 --> 00:05:46.280 align:start position:0%
10 and five we add them both into the
 

00:05:46.280 --> 00:05:48.430 align:start position:0%
10 and five we add them both into the
work<00:05:46.560><c> list</c><00:05:47.000><c> and</c><00:05:47.319><c> at</c><00:05:47.479><c> this</c><00:05:47.720><c> point</c><00:05:47.919><c> we</c><00:05:48.080><c> also</c><00:05:48.319><c> have</c>

00:05:48.430 --> 00:05:48.440 align:start position:0%
work list and at this point we also have
 

00:05:48.440 --> 00:05:51.350 align:start position:0%
work list and at this point we also have
to<00:05:48.600><c> record</c><00:05:49.199><c> the</c><00:05:49.360><c> stack</c><00:05:49.800><c> height</c><00:05:50.800><c> uh</c><00:05:50.919><c> at</c><00:05:51.080><c> both</c><00:05:51.280><c> of</c>

00:05:51.350 --> 00:05:51.360 align:start position:0%
to record the stack height uh at both of
 

00:05:51.360 --> 00:05:53.270 align:start position:0%
to record the stack height uh at both of
the<00:05:51.479><c> targets</c><00:05:52.039><c> stack</c><00:05:52.319><c> height</c><00:05:52.520><c> is</c><00:05:52.639><c> zero</c><00:05:52.880><c> after</c><00:05:53.080><c> R</c>

00:05:53.270 --> 00:05:53.280 align:start position:0%
the targets stack height is zero after R
 

00:05:53.280 --> 00:05:56.189 align:start position:0%
the targets stack height is zero after R
jump<00:05:53.520><c> I</c><00:05:53.759><c> so</c><00:05:53.919><c> we</c><00:05:54.039><c> record</c><00:05:54.479><c> that</c><00:05:54.840><c> at</c><00:05:55.039><c> both</c><00:05:55.360><c> offsets</c>

00:05:56.189 --> 00:05:56.199 align:start position:0%
jump I so we record that at both offsets
 

00:05:56.199 --> 00:05:58.790 align:start position:0%
jump I so we record that at both offsets
and<00:05:56.400><c> continue</c><00:05:57.080><c> then</c><00:05:57.479><c> with</c><00:05:57.680><c> the</c><00:05:58.160><c> next</c><00:05:58.440><c> Branch</c>

00:05:58.790 --> 00:05:58.800 align:start position:0%
and continue then with the next Branch
 

00:05:58.800 --> 00:06:00.590 align:start position:0%
and continue then with the next Branch
from<00:05:58.919><c> the</c><00:05:59.039><c> work</c><00:05:59.280><c> list</c><00:05:59.440><c> we</c><00:05:59.680><c> go</c><00:05:59.800><c> to</c><00:05:59.960><c> offset</c><00:06:00.280><c> zero</c>

00:06:00.590 --> 00:06:00.600 align:start position:0%
from the work list we go to offset zero
 

00:06:00.600 --> 00:06:02.430 align:start position:0%
from the work list we go to offset zero
there<00:06:00.759><c> there's</c><00:06:00.960><c> a</c><00:06:01.080><c> push</c><00:06:01.319><c> and</c><00:06:01.479><c> another</c><00:06:01.800><c> push</c>

00:06:02.430 --> 00:06:02.440 align:start position:0%
there there's a push and another push
 

00:06:02.440 --> 00:06:05.550 align:start position:0%
there there's a push and another push
then<00:06:02.639><c> a</c><00:06:02.880><c> store</c><00:06:03.560><c> checks</c><00:06:04.560><c> whether</c><00:06:05.080><c> it</c><00:06:05.280><c> has</c>

00:06:05.550 --> 00:06:05.560 align:start position:0%
then a store checks whether it has
 

00:06:05.560 --> 00:06:08.550 align:start position:0%
then a store checks whether it has
enough<00:06:05.960><c> items</c><00:06:06.440><c> not</c><00:06:06.599><c> to</c><00:06:06.800><c> under</c>

00:06:08.550 --> 00:06:08.560 align:start position:0%
enough items not to under
 

00:06:08.560 --> 00:06:11.670 align:start position:0%
enough items not to under
underflow<00:06:09.560><c> uh</c><00:06:10.000><c> two</c><00:06:10.280><c> is</c><00:06:10.400><c> exactly</c><00:06:10.800><c> enough</c><00:06:11.039><c> for</c><00:06:11.400><c> S</c>

00:06:11.670 --> 00:06:11.680 align:start position:0%
underflow uh two is exactly enough for S
 

00:06:11.680 --> 00:06:13.710 align:start position:0%
underflow uh two is exactly enough for S
stor<00:06:12.120><c> so</c><00:06:12.360><c> no</c><00:06:12.520><c> underlow</c><00:06:13.000><c> happens</c><00:06:13.280><c> we</c><00:06:13.360><c> are</c><00:06:13.479><c> good</c>

00:06:13.710 --> 00:06:13.720 align:start position:0%
stor so no underlow happens we are good
 

00:06:13.720 --> 00:06:17.029 align:start position:0%
stor so no underlow happens we are good
here<00:06:14.160><c> and</c><00:06:14.360><c> we</c><00:06:14.560><c> continue</c><00:06:15.560><c> uh</c><00:06:16.199><c> this</c><00:06:16.479><c> stop</c><00:06:16.840><c> then</c>

00:06:17.029 --> 00:06:17.039 align:start position:0%
here and we continue uh this stop then
 

00:06:17.039 --> 00:06:19.870 align:start position:0%
here and we continue uh this stop then
validates<00:06:17.919><c> uh</c><00:06:18.240><c> uh</c><00:06:18.800><c> concludes</c><00:06:19.280><c> validation</c><00:06:19.680><c> of</c>

00:06:19.870 --> 00:06:19.880 align:start position:0%
validates uh uh concludes validation of
 

00:06:19.880 --> 00:06:22.550 align:start position:0%
validates uh uh concludes validation of
this<00:06:20.080><c> branch</c><00:06:21.000><c> and</c><00:06:21.160><c> we</c><00:06:21.319><c> have</c><00:06:21.520><c> still</c><00:06:21.800><c> one</c><00:06:22.199><c> branch</c>

00:06:22.550 --> 00:06:22.560 align:start position:0%
this branch and we have still one branch
 

00:06:22.560 --> 00:06:24.790 align:start position:0%
this branch and we have still one branch
left<00:06:22.759><c> to</c><00:06:23.000><c> examine</c><00:06:23.599><c> at</c><00:06:23.759><c> offset</c><00:06:24.199><c> five</c><00:06:24.440><c> we</c><00:06:24.560><c> go</c>

00:06:24.790 --> 00:06:24.800 align:start position:0%
left to examine at offset five we go
 

00:06:24.800 --> 00:06:26.950 align:start position:0%
left to examine at offset five we go
there<00:06:25.080><c> there's</c><00:06:25.440><c> another</c><00:06:25.720><c> push</c><00:06:26.080><c> and</c><00:06:26.280><c> then</c>

00:06:26.950 --> 00:06:26.960 align:start position:0%
there there's another push and then
 

00:06:26.960 --> 00:06:28.749 align:start position:0%
there there's another push and then
another<00:06:27.319><c> jump</c><00:06:27.680><c> into</c><00:06:27.960><c> the</c><00:06:28.160><c> Target</c><00:06:28.520><c> that</c><00:06:28.639><c> we</c>

00:06:28.749 --> 00:06:28.759 align:start position:0%
another jump into the Target that we
 

00:06:28.759 --> 00:06:30.309 align:start position:0%
another jump into the Target that we
have<00:06:28.919><c> already</c><00:06:29.199><c> visited</c><00:06:29.680><c> before</c><00:06:29.960><c> at</c><00:06:30.120><c> this</c>

00:06:30.309 --> 00:06:30.319 align:start position:0%
have already visited before at this
 

00:06:30.319 --> 00:06:31.710 align:start position:0%
have already visited before at this
point<00:06:30.560><c> we</c><00:06:30.680><c> have</c><00:06:30.800><c> to</c><00:06:30.960><c> check</c><00:06:31.199><c> whether</c><00:06:31.440><c> current</c>

00:06:31.710 --> 00:06:31.720 align:start position:0%
point we have to check whether current
 

00:06:31.720 --> 00:06:34.029 align:start position:0%
point we have to check whether current
stack<00:06:32.039><c> height</c><00:06:32.319><c> is</c><00:06:32.479><c> equal</c><00:06:32.759><c> to</c><00:06:33.599><c> what</c><00:06:33.759><c> we</c><00:06:33.880><c> have</c>

00:06:34.029 --> 00:06:34.039 align:start position:0%
stack height is equal to what we have
 

00:06:34.039 --> 00:06:37.270 align:start position:0%
stack height is equal to what we have
recorded<00:06:34.840><c> for</c><00:06:35.160><c> this</c><00:06:35.639><c> target</c><00:06:36.080><c> before</c><00:06:36.400><c> it</c><00:06:36.560><c> was</c>

00:06:37.270 --> 00:06:37.280 align:start position:0%
recorded for this target before it was
 

00:06:37.280 --> 00:06:39.670 align:start position:0%
recorded for this target before it was
one<00:06:37.720><c> previously</c><00:06:38.319><c> and</c><00:06:38.680><c> stack</c><00:06:39.080><c> height</c><00:06:39.280><c> is</c><00:06:39.440><c> also</c>

00:06:39.670 --> 00:06:39.680 align:start position:0%
one previously and stack height is also
 

00:06:39.680 --> 00:06:42.309 align:start position:0%
one previously and stack height is also
one<00:06:39.919><c> for</c><00:06:40.160><c> this</c><00:06:40.880><c> after</c><00:06:41.160><c> this</c><00:06:41.319><c> R</c><00:06:41.560><c> jump</c><00:06:41.880><c> so</c><00:06:42.080><c> 1</c>

00:06:42.309 --> 00:06:42.319 align:start position:0%
one for this after this R jump so 1
 

00:06:42.319 --> 00:06:46.070 align:start position:0%
one for this after this R jump so 1
equals<00:06:43.280><c> one</c><00:06:44.280><c> and</c><00:06:44.919><c> uh</c><00:06:45.080><c> so</c><00:06:45.280><c> this</c><00:06:45.360><c> is</c><00:06:45.599><c> valid</c><00:06:45.840><c> we</c><00:06:45.960><c> do</c>

00:06:46.070 --> 00:06:46.080 align:start position:0%
equals one and uh so this is valid we do
 

00:06:46.080 --> 00:06:48.230 align:start position:0%
equals one and uh so this is valid we do
not<00:06:46.360><c> revisit</c><00:06:46.880><c> this</c><00:06:47.039><c> Branch</c><00:06:47.440><c> anymore</c><00:06:47.919><c> and</c><00:06:48.080><c> then</c>

00:06:48.230 --> 00:06:48.240 align:start position:0%
not revisit this Branch anymore and then
 

00:06:48.240 --> 00:06:49.589 align:start position:0%
not revisit this Branch anymore and then
we<00:06:48.319><c> do</c><00:06:48.440><c> not</c><00:06:48.599><c> have</c><00:06:48.759><c> anything</c><00:06:49.000><c> else</c><00:06:49.160><c> in</c><00:06:49.240><c> the</c><00:06:49.360><c> work</c>

00:06:49.589 --> 00:06:49.599 align:start position:0%
we do not have anything else in the work
 

00:06:49.599 --> 00:06:51.390 align:start position:0%
we do not have anything else in the work
list<00:06:50.000><c> and</c><00:06:50.240><c> this</c><00:06:50.440><c> concludes</c><00:06:50.840><c> the</c><00:06:50.960><c> validation</c>

00:06:51.390 --> 00:06:51.400 align:start position:0%
list and this concludes the validation
 

00:06:51.400 --> 00:06:53.589 align:start position:0%
list and this concludes the validation
this<00:06:51.560><c> code</c><00:06:51.759><c> is</c><00:06:51.919><c> valid</c><00:06:52.160><c> in</c><00:06:52.240><c> the</c><00:06:52.360><c> end</c><00:06:53.199><c> compare</c>

00:06:53.589 --> 00:06:53.599 align:start position:0%
this code is valid in the end compare
 

00:06:53.599 --> 00:06:56.230 align:start position:0%
this code is valid in the end compare
this<00:06:53.759><c> to</c><00:06:53.960><c> this</c><00:06:54.240><c> invalid</c><00:06:55.199><c> code</c><00:06:55.680><c> it</c><00:06:55.800><c> is</c><00:06:56.039><c> very</c>

00:06:56.230 --> 00:06:56.240 align:start position:0%
this to this invalid code it is very
 

00:06:56.240 --> 00:06:58.749 align:start position:0%
this to this invalid code it is very
similar<00:06:56.599><c> but</c><00:06:56.800><c> with</c><00:06:56.960><c> one</c><00:06:57.199><c> push</c><00:06:57.520><c> emitted</c><00:06:58.280><c> uh</c><00:06:58.520><c> so</c>

00:06:58.749 --> 00:06:58.759 align:start position:0%
similar but with one push emitted uh so
 

00:06:58.759 --> 00:07:01.270 align:start position:0%
similar but with one push emitted uh so
it<00:06:58.879><c> goes</c><00:06:59.120><c> through</c><00:06:59.319><c> very</c><00:06:59.720><c> similar</c><00:07:00.160><c> steps</c><00:07:00.639><c> and</c>

00:07:01.270 --> 00:07:01.280 align:start position:0%
it goes through very similar steps and
 

00:07:01.280 --> 00:07:03.469 align:start position:0%
it goes through very similar steps and
ends<00:07:01.639><c> up</c><00:07:01.919><c> at</c><00:07:02.120><c> this</c><00:07:02.360><c> R</c><00:07:02.680><c> jump</c>

00:07:03.469 --> 00:07:03.479 align:start position:0%
ends up at this R jump
 

00:07:03.479 --> 00:07:05.550 align:start position:0%
ends up at this R jump
instruction<00:07:04.479><c> uh</c><00:07:04.599><c> and</c><00:07:04.759><c> at</c><00:07:04.879><c> this</c><00:07:05.039><c> point</c><00:07:05.240><c> stack</c>

00:07:05.550 --> 00:07:05.560 align:start position:0%
instruction uh and at this point stack
 

00:07:05.560 --> 00:07:07.909 align:start position:0%
instruction uh and at this point stack
height<00:07:05.759><c> is</c><00:07:05.919><c> zero</c><00:07:06.360><c> but</c><00:07:06.520><c> we</c><00:07:06.680><c> have</c><00:07:06.879><c> seen</c><00:07:07.599><c> stack</c>

00:07:07.909 --> 00:07:07.919 align:start position:0%
height is zero but we have seen stack
 

00:07:07.919 --> 00:07:10.309 align:start position:0%
height is zero but we have seen stack
height<00:07:08.160><c> one</c><00:07:08.440><c> at</c><00:07:08.560><c> the</c><00:07:08.720><c> Target</c><00:07:09.120><c> before</c><00:07:09.720><c> and</c><00:07:10.120><c> so</c>

00:07:10.309 --> 00:07:10.319 align:start position:0%
height one at the Target before and so
 

00:07:10.319 --> 00:07:12.430 align:start position:0%
height one at the Target before and so
they<00:07:10.440><c> are</c><00:07:10.560><c> not</c><00:07:10.680><c> equal</c><00:07:11.080><c> and</c><00:07:11.319><c> this</c><00:07:11.879><c> means</c><00:07:12.240><c> code</c>

00:07:12.430 --> 00:07:12.440 align:start position:0%
they are not equal and this means code
 

00:07:12.440 --> 00:07:14.270 align:start position:0%
they are not equal and this means code
is<00:07:12.560><c> invalid</c><00:07:12.919><c> and</c>

00:07:14.270 --> 00:07:14.280 align:start position:0%
is invalid and
 

00:07:14.280 --> 00:07:17.430 align:start position:0%
is invalid and
rejected<00:07:15.280><c> so</c><00:07:15.720><c> this</c><00:07:16.120><c> uh</c><00:07:16.280><c> exact</c><00:07:16.840><c> restriction</c>

00:07:17.430 --> 00:07:17.440 align:start position:0%
rejected so this uh exact restriction
 

00:07:17.440 --> 00:07:19.150 align:start position:0%
rejected so this uh exact restriction
that<00:07:17.560><c> makes</c><00:07:17.759><c> it</c><00:07:17.879><c> all</c><00:07:18.120><c> possible</c><00:07:18.639><c> uh</c><00:07:18.720><c> turned</c><00:07:19.000><c> out</c>

00:07:19.150 --> 00:07:19.160 align:start position:0%
that makes it all possible uh turned out
 

00:07:19.160 --> 00:07:21.469 align:start position:0%
that makes it all possible uh turned out
to<00:07:19.280><c> be</c><00:07:19.440><c> problematic</c><00:07:19.919><c> in</c><00:07:20.080><c> some</c><00:07:20.280><c> important</c>

00:07:21.469 --> 00:07:21.479 align:start position:0%
to be problematic in some important
 

00:07:21.479 --> 00:07:25.469 align:start position:0%
to be problematic in some important
cases<00:07:22.479><c> so</c><00:07:22.720><c> this</c><00:07:22.879><c> code</c><00:07:23.360><c> like</c><00:07:23.720><c> on</c><00:07:23.840><c> the</c><00:07:24.319><c> slide</c><00:07:25.319><c> uh</c>

00:07:25.469 --> 00:07:25.479 align:start position:0%
cases so this code like on the slide uh
 

00:07:25.479 --> 00:07:28.589 align:start position:0%
cases so this code like on the slide uh
can<00:07:25.720><c> be</c><00:07:26.360><c> commonly</c><00:07:27.120><c> generated</c><00:07:27.800><c> by</c><00:07:28.039><c> solidity</c>

00:07:28.589 --> 00:07:28.599 align:start position:0%
can be commonly generated by solidity
 

00:07:28.599 --> 00:07:30.309 align:start position:0%
can be commonly generated by solidity
for<00:07:28.800><c> example</c><00:07:29.080><c> when</c><00:07:29.199><c> you</c><00:07:29.319><c> have</c><00:07:29.599><c> a</c><00:07:29.759><c> series</c><00:07:30.080><c> of</c>

00:07:30.309 --> 00:07:30.319 align:start position:0%
for example when you have a series of
 

00:07:30.319 --> 00:07:32.749 align:start position:0%
for example when you have a series of
requir<00:07:30.720><c> statements</c><00:07:31.080><c> in</c><00:07:31.240><c> solidity</c><00:07:31.840><c> every</c>

00:07:32.749 --> 00:07:32.759 align:start position:0%
requir statements in solidity every
 

00:07:32.759 --> 00:07:35.189 align:start position:0%
requir statements in solidity every
require<00:07:33.280><c> is</c><00:07:33.759><c> a</c><00:07:33.960><c> check</c><00:07:34.240><c> and</c><00:07:34.440><c> revert</c><00:07:34.919><c> in</c><00:07:35.039><c> case</c>

00:07:35.189 --> 00:07:35.199 align:start position:0%
require is a check and revert in case
 

00:07:35.199 --> 00:07:38.189 align:start position:0%
require is a check and revert in case
it's<00:07:35.400><c> not</c><00:07:36.280><c> uh</c><00:07:36.440><c> satisfied</c><00:07:37.199><c> and</c><00:07:37.400><c> then</c><00:07:38.080><c> uh</c>

00:07:38.189 --> 00:07:38.199 align:start position:0%
it's not uh satisfied and then uh
 

00:07:38.199 --> 00:07:40.430 align:start position:0%
it's not uh satisfied and then uh
solidity<00:07:38.680><c> Optimizer</c><00:07:39.240><c> at</c><00:07:39.360><c> some</c><00:07:39.560><c> point</c>

00:07:40.430 --> 00:07:40.440 align:start position:0%
solidity Optimizer at some point
 

00:07:40.440 --> 00:07:43.070 align:start position:0%
solidity Optimizer at some point
extracts<00:07:41.000><c> these</c><00:07:41.280><c> reverts</c><00:07:41.759><c> into</c><00:07:41.960><c> a</c><00:07:42.199><c> common</c><00:07:42.960><c> uh</c>

00:07:43.070 --> 00:07:43.080 align:start position:0%
extracts these reverts into a common uh
 

00:07:43.080 --> 00:07:46.189 align:start position:0%
extracts these reverts into a common uh
code<00:07:43.680><c> uh</c><00:07:43.840><c> common</c><00:07:44.120><c> code</c><00:07:44.360><c> block</c><00:07:45.120><c> and</c><00:07:45.440><c> uh</c><00:07:45.879><c> then</c>

00:07:46.189 --> 00:07:46.199 align:start position:0%
code uh common code block and uh then
 

00:07:46.199 --> 00:07:48.070 align:start position:0%
code uh common code block and uh then
each<00:07:46.560><c> require</c><00:07:47.000><c> becomes</c><00:07:47.400><c> this</c><00:07:47.599><c> check</c><00:07:47.800><c> anded</c>

00:07:48.070 --> 00:07:48.080 align:start position:0%
each require becomes this check anded
 

00:07:48.080 --> 00:07:50.909 align:start position:0%
each require becomes this check anded
jump<00:07:48.479><c> into</c><00:07:48.720><c> this</c><00:07:48.919><c> common</c><00:07:49.400><c> code</c><00:07:50.400><c> uh</c><00:07:50.520><c> so</c><00:07:50.759><c> the</c>

00:07:50.909 --> 00:07:50.919 align:start position:0%
jump into this common code uh so the
 

00:07:50.919 --> 00:07:53.749 align:start position:0%
jump into this common code uh so the
problem<00:07:51.280><c> here</c><00:07:52.240><c> these</c><00:07:52.680><c> uh</c><00:07:52.840><c> requires</c><00:07:53.479><c> and</c><00:07:53.599><c> these</c>

00:07:53.749 --> 00:07:53.759 align:start position:0%
problem here these uh requires and these
 

00:07:53.759 --> 00:07:55.830 align:start position:0%
problem here these uh requires and these
checks<00:07:54.000><c> and</c><00:07:54.159><c> jumps</c><00:07:54.520><c> can</c><00:07:54.919><c> be</c><00:07:55.159><c> located</c><00:07:55.639><c> at</c>

00:07:55.830 --> 00:07:55.840 align:start position:0%
checks and jumps can be located at
 

00:07:55.840 --> 00:07:57.950 align:start position:0%
checks and jumps can be located at
arbitary<00:07:56.400><c> points</c><00:07:56.680><c> in</c><00:07:56.800><c> the</c><00:07:56.919><c> function</c><00:07:57.319><c> code</c><00:07:57.720><c> and</c>

00:07:57.950 --> 00:07:57.960 align:start position:0%
arbitary points in the function code and
 

00:07:57.960 --> 00:08:01.589 align:start position:0%
arbitary points in the function code and
at<00:07:58.159><c> arbitary</c><00:07:58.720><c> stack</c><00:07:59.080><c> Heights</c><00:07:59.800><c> and</c><00:08:00.759><c> this</c><00:08:01.120><c> goes</c>

00:08:01.589 --> 00:08:01.599 align:start position:0%
at arbitary stack Heights and this goes
 

00:08:01.599 --> 00:08:03.230 align:start position:0%
at arbitary stack Heights and this goes
specifically<00:08:02.120><c> against</c><00:08:02.400><c> our</c><00:08:02.599><c> rule</c><00:08:02.840><c> that</c><00:08:02.960><c> stack</c>

00:08:03.230 --> 00:08:03.240 align:start position:0%
specifically against our rule that stack
 

00:08:03.240 --> 00:08:04.990 align:start position:0%
specifically against our rule that stack
height<00:08:03.440><c> must</c><00:08:03.599><c> be</c><00:08:03.759><c> equal</c><00:08:04.080><c> at</c>

00:08:04.990 --> 00:08:05.000 align:start position:0%
height must be equal at
 

00:08:05.000 --> 00:08:08.990 align:start position:0%
height must be equal at
every<00:08:06.000><c> every</c><00:08:06.400><c> jump</c><00:08:06.759><c> into</c><00:08:07.360><c> uh</c><00:08:07.759><c> common</c>

00:08:08.990 --> 00:08:09.000 align:start position:0%
every every jump into uh common
 

00:08:09.000 --> 00:08:12.270 align:start position:0%
every every jump into uh common
code<00:08:10.000><c> uh</c><00:08:10.840><c> compilers</c><00:08:11.479><c> could</c><00:08:11.680><c> deal</c><00:08:11.919><c> with</c><00:08:12.080><c> it</c>

00:08:12.270 --> 00:08:12.280 align:start position:0%
code uh compilers could deal with it
 

00:08:12.280 --> 00:08:14.589 align:start position:0%
code uh compilers could deal with it
with<00:08:12.440><c> some</c><00:08:12.680><c> workarounds</c><00:08:13.599><c> for</c><00:08:13.759><c> example</c><00:08:14.400><c> they</c>

00:08:14.589 --> 00:08:14.599 align:start position:0%
with some workarounds for example they
 

00:08:14.599 --> 00:08:16.749 align:start position:0%
with some workarounds for example they
could<00:08:15.080><c> uh</c><00:08:15.199><c> insert</c><00:08:15.919><c> some</c><00:08:16.159><c> extra</c><00:08:16.520><c> Pop</c>

00:08:16.749 --> 00:08:16.759 align:start position:0%
could uh insert some extra Pop
 

00:08:16.759 --> 00:08:18.230 align:start position:0%
could uh insert some extra Pop
instructions<00:08:17.199><c> before</c><00:08:17.440><c> some</c><00:08:17.680><c> jumps</c><00:08:18.000><c> to</c>

00:08:18.230 --> 00:08:18.240 align:start position:0%
instructions before some jumps to
 

00:08:18.240 --> 00:08:19.909 align:start position:0%
instructions before some jumps to
equalize<00:08:18.680><c> the</c><00:08:18.840><c> stack</c><00:08:19.039><c> and</c><00:08:19.199><c> make</c><00:08:19.319><c> it</c><00:08:19.479><c> equal</c><00:08:19.720><c> for</c>

00:08:19.909 --> 00:08:19.919 align:start position:0%
equalize the stack and make it equal for
 

00:08:19.919 --> 00:08:22.350 align:start position:0%
equalize the stack and make it equal for
every<00:08:20.159><c> jump</c><00:08:20.440><c> into</c><00:08:20.599><c> a</c><00:08:20.720><c> common</c><00:08:21.000><c> code</c><00:08:22.000><c> but</c><00:08:22.240><c> this</c>

00:08:22.350 --> 00:08:22.360 align:start position:0%
every jump into a common code but this
 

00:08:22.360 --> 00:08:24.909 align:start position:0%
every jump into a common code but this
would<00:08:22.560><c> mean</c><00:08:22.919><c> increased</c><00:08:23.560><c> code</c><00:08:23.919><c> size</c><00:08:24.599><c> and</c>

00:08:24.909 --> 00:08:24.919 align:start position:0%
would mean increased code size and
 

00:08:24.919 --> 00:08:28.230 align:start position:0%
would mean increased code size and
increased<00:08:25.360><c> gas</c><00:08:25.599><c> consumed</c><00:08:26.440><c> so</c><00:08:27.000><c> this</c><00:08:27.319><c> entire</c>

00:08:28.230 --> 00:08:28.240 align:start position:0%
increased gas consumed so this entire
 

00:08:28.240 --> 00:08:29.950 align:start position:0%
increased gas consumed so this entire
optimization<00:08:28.840><c> might</c><00:08:29.039><c> not</c><00:08:29.159><c> be</c><00:08:29.520><c> worth</c><00:08:29.720><c> it</c><00:08:29.879><c> in</c>

00:08:29.950 --> 00:08:29.960 align:start position:0%
optimization might not be worth it in
 

00:08:29.960 --> 00:08:32.630 align:start position:0%
optimization might not be worth it in
the<00:08:30.280><c> end</c><00:08:31.280><c> or</c><00:08:31.479><c> another</c><00:08:31.720><c> workaround</c><00:08:32.279><c> could</c><00:08:32.440><c> be</c>

00:08:32.630 --> 00:08:32.640 align:start position:0%
the end or another workaround could be
 

00:08:32.640 --> 00:08:35.190 align:start position:0%
the end or another workaround could be
to<00:08:32.959><c> take</c><00:08:33.159><c> this</c><00:08:33.399><c> revert</c><00:08:33.880><c> and</c><00:08:34.039><c> make</c><00:08:34.240><c> an</c><00:08:34.839><c> uh</c>

00:08:35.190 --> 00:08:35.200 align:start position:0%
to take this revert and make an uh
 

00:08:35.200 --> 00:08:37.029 align:start position:0%
to take this revert and make an uh
separate<00:08:35.599><c> code</c><00:08:35.839><c> section</c><00:08:36.159><c> out</c><00:08:36.279><c> of</c><00:08:36.440><c> it</c><00:08:36.680><c> and</c><00:08:36.839><c> call</c>

00:08:37.029 --> 00:08:37.039 align:start position:0%
separate code section out of it and call
 

00:08:37.039 --> 00:08:39.750 align:start position:0%
separate code section out of it and call
it<00:08:37.159><c> from</c><00:08:37.399><c> here</c><00:08:37.880><c> this</c><00:08:38.000><c> would</c><00:08:38.200><c> also</c><00:08:38.479><c> work</c><00:08:38.959><c> but</c>

00:08:39.750 --> 00:08:39.760 align:start position:0%
it from here this would also work but
 

00:08:39.760 --> 00:08:44.149 align:start position:0%
it from here this would also work but
this<00:08:40.000><c> also</c><00:08:40.320><c> has</c><00:08:40.440><c> an</c><00:08:40.640><c> overhead</c><00:08:41.320><c> of</c><00:08:42.120><c> um</c><00:08:43.159><c> putting</c>

00:08:44.149 --> 00:08:44.159 align:start position:0%
this also has an overhead of um putting
 

00:08:44.159 --> 00:08:46.030 align:start position:0%
this also has an overhead of um putting
declaring<00:08:44.680><c> this</c><00:08:44.920><c> extra</c><00:08:45.279><c> code</c><00:08:45.560><c> section</c><00:08:45.760><c> in</c><00:08:45.920><c> the</c>

00:08:46.030 --> 00:08:46.040 align:start position:0%
declaring this extra code section in the
 

00:08:46.040 --> 00:08:48.389 align:start position:0%
declaring this extra code section in the
UF<00:08:46.440><c> header</c><00:08:46.880><c> putting</c><00:08:47.200><c> its</c><00:08:47.360><c> metadata</c><00:08:47.800><c> into</c><00:08:48.080><c> type</c>

00:08:48.389 --> 00:08:48.399 align:start position:0%
UF header putting its metadata into type
 

00:08:48.399 --> 00:08:50.990 align:start position:0%
UF header putting its metadata into type
section<00:08:49.399><c> so</c><00:08:49.600><c> in</c><00:08:49.720><c> the</c><00:08:49.839><c> end</c><00:08:50.160><c> code</c><00:08:50.440><c> size</c><00:08:50.640><c> also</c><00:08:50.880><c> is</c>

00:08:50.990 --> 00:08:51.000 align:start position:0%
section so in the end code size also is
 

00:08:51.000 --> 00:08:52.590 align:start position:0%
section so in the end code size also is
increased<00:08:51.560><c> and</c><00:08:51.760><c> we</c><00:08:51.920><c> might</c><00:08:52.160><c> have</c><00:08:52.399><c> some</c>

00:08:52.590 --> 00:08:52.600 align:start position:0%
increased and we might have some
 

00:08:52.600 --> 00:08:54.870 align:start position:0%
increased and we might have some
regressions<00:08:53.240><c> comparing</c><00:08:53.680><c> to</c><00:08:54.040><c> current</c><00:08:54.360><c> evm</c>

00:08:54.870 --> 00:08:54.880 align:start position:0%
regressions comparing to current evm
 

00:08:54.880 --> 00:08:56.310 align:start position:0%
regressions comparing to current evm
this<00:08:54.959><c> is</c><00:08:55.160><c> something</c><00:08:55.519><c> we</c><00:08:55.800><c> really</c><00:08:56.000><c> would</c><00:08:56.200><c> like</c>

00:08:56.310 --> 00:08:56.320 align:start position:0%
this is something we really would like
 

00:08:56.320 --> 00:08:59.230 align:start position:0%
this is something we really would like
to<00:08:56.920><c> avoid</c><00:08:57.920><c> uh</c><00:08:58.200><c> and</c><00:08:58.360><c> this</c><00:08:58.480><c> is</c><00:08:58.640><c> just</c><00:08:58.800><c> one</c><00:08:59.000><c> common</c>

00:08:59.230 --> 00:08:59.240 align:start position:0%
to avoid uh and this is just one common
 

00:08:59.240 --> 00:09:01.230 align:start position:0%
to avoid uh and this is just one common
examp<00:08:59.480><c> example</c><00:08:59.839><c> it's</c><00:09:00.040><c> not</c><00:09:00.200><c> the</c><00:09:00.320><c> only</c><00:09:00.560><c> one</c><00:09:01.120><c> in</c>

00:09:01.230 --> 00:09:01.240 align:start position:0%
examp example it's not the only one in
 

00:09:01.240 --> 00:09:04.870 align:start position:0%
examp example it's not the only one in
general<00:09:01.800><c> compilers</c><00:09:02.360><c> are</c><00:09:02.560><c> very</c><00:09:02.800><c> much</c><00:09:03.600><c> um</c><00:09:04.560><c> uh</c><00:09:04.680><c> in</c>

00:09:04.870 --> 00:09:04.880 align:start position:0%
general compilers are very much um uh in
 

00:09:04.880 --> 00:09:08.550 align:start position:0%
general compilers are very much um uh in
favor<00:09:05.200><c> of</c><00:09:05.560><c> being</c><00:09:06.079><c> able</c><00:09:06.680><c> to</c><00:09:07.560><c> jump</c><00:09:07.959><c> into</c><00:09:08.240><c> some</c>

00:09:08.550 --> 00:09:08.560 align:start position:0%
favor of being able to jump into some
 

00:09:08.560 --> 00:09:11.230 align:start position:0%
favor of being able to jump into some
common<00:09:09.320><c> uh</c><00:09:09.760><c> helper</c><00:09:10.240><c> code</c><00:09:10.519><c> blocks</c><00:09:11.000><c> from</c>

00:09:11.230 --> 00:09:11.240 align:start position:0%
common uh helper code blocks from
 

00:09:11.240 --> 00:09:12.949 align:start position:0%
common uh helper code blocks from
arbitrary<00:09:11.760><c> stack</c>

00:09:12.949 --> 00:09:12.959 align:start position:0%
arbitrary stack
 

00:09:12.959 --> 00:09:15.829 align:start position:0%
arbitrary stack
Heights<00:09:13.959><c> so</c><00:09:14.160><c> we</c><00:09:14.279><c> found</c><00:09:14.600><c> a</c><00:09:14.800><c> solution</c><00:09:15.399><c> to</c><00:09:15.600><c> this</c>

00:09:15.829 --> 00:09:15.839 align:start position:0%
Heights so we found a solution to this
 

00:09:15.839 --> 00:09:18.150 align:start position:0%
Heights so we found a solution to this
and<00:09:16.000><c> this</c><00:09:16.120><c> is</c><00:09:16.320><c> current</c><00:09:16.600><c> spec</c><00:09:16.839><c> of</c><00:09:16.959><c> 50450</c><00:09:17.760><c> and</c>

00:09:18.150 --> 00:09:18.160 align:start position:0%
and this is current spec of 50450 and
 

00:09:18.160 --> 00:09:21.470 align:start position:0%
and this is current spec of 50450 and
final<00:09:18.720><c> one</c><00:09:19.720><c> uh</c><00:09:20.040><c> so</c><00:09:20.279><c> we</c><00:09:20.440><c> have</c><00:09:20.600><c> to</c><00:09:20.760><c> modify</c><00:09:21.240><c> our</c>

00:09:21.470 --> 00:09:21.480 align:start position:0%
final one uh so we have to modify our
 

00:09:21.480 --> 00:09:23.470 align:start position:0%
final one uh so we have to modify our
algorithm<00:09:22.360><c> somewhat</c><00:09:22.800><c> in</c><00:09:22.920><c> some</c><00:09:23.079><c> important</c>

00:09:23.470 --> 00:09:23.480 align:start position:0%
algorithm somewhat in some important
 

00:09:23.480 --> 00:09:26.670 align:start position:0%
algorithm somewhat in some important
ways<00:09:24.480><c> uh</c><00:09:25.480><c> uh</c><00:09:25.560><c> we</c><00:09:25.720><c> start</c><00:09:26.000><c> with</c><00:09:26.160><c> allowing</c>

00:09:26.670 --> 00:09:26.680 align:start position:0%
ways uh uh we start with allowing
 

00:09:26.680 --> 00:09:28.150 align:start position:0%
ways uh uh we start with allowing
multiple<00:09:27.120><c> possible</c><00:09:27.399><c> stack</c><00:09:27.720><c> Heights</c><00:09:27.959><c> for</c>

00:09:28.150 --> 00:09:28.160 align:start position:0%
multiple possible stack Heights for
 

00:09:28.160 --> 00:09:30.350 align:start position:0%
multiple possible stack Heights for
every<00:09:28.399><c> instruction</c><00:09:29.040><c> in</c><00:09:29.360><c> instead</c><00:09:29.600><c> of</c><00:09:30.240><c> uh</c>

00:09:30.350 --> 00:09:30.360 align:start position:0%
every instruction in instead of uh
 

00:09:30.360 --> 00:09:32.470 align:start position:0%
every instruction in instead of uh
recording<00:09:30.880><c> just</c><00:09:31.040><c> one</c><00:09:31.240><c> stack</c><00:09:31.560><c> height</c><00:09:31.800><c> value</c><00:09:32.279><c> we</c>

00:09:32.470 --> 00:09:32.480 align:start position:0%
recording just one stack height value we
 

00:09:32.480 --> 00:09:34.750 align:start position:0%
recording just one stack height value we
record<00:09:33.360><c> uh</c><00:09:33.560><c> the</c><00:09:33.680><c> range</c><00:09:33.959><c> of</c><00:09:34.079><c> Stack</c><00:09:34.360><c> Heights</c><00:09:34.560><c> to</c>

00:09:34.750 --> 00:09:34.760 align:start position:0%
record uh the range of Stack Heights to
 

00:09:34.760 --> 00:09:36.509 align:start position:0%
record uh the range of Stack Heights to
minimum<00:09:35.160><c> and</c><00:09:35.360><c> maximum</c><00:09:35.959><c> for</c><00:09:36.200><c> every</c>

00:09:36.509 --> 00:09:36.519 align:start position:0%
minimum and maximum for every
 

00:09:36.519 --> 00:09:38.470 align:start position:0%
minimum and maximum for every
instruction<00:09:37.519><c> we</c><00:09:37.640><c> change</c><00:09:37.920><c> the</c><00:09:38.040><c> way</c><00:09:38.240><c> we</c>

00:09:38.470 --> 00:09:38.480 align:start position:0%
instruction we change the way we
 

00:09:38.480 --> 00:09:41.310 align:start position:0%
instruction we change the way we
Traverse<00:09:38.920><c> the</c><00:09:39.040><c> code</c><00:09:39.480><c> instead</c><00:09:39.839><c> of</c><00:09:40.519><c> uh</c><00:09:41.040><c> depth</c>

00:09:41.310 --> 00:09:41.320 align:start position:0%
Traverse the code instead of uh depth
 

00:09:41.320 --> 00:09:42.710 align:start position:0%
Traverse the code instead of uh depth
res<00:09:41.480><c> search</c><00:09:41.640><c> or</c><00:09:41.760><c> bread</c><00:09:41.959><c> for</c><00:09:42.079><c> search</c><00:09:42.279><c> reversal</c>

00:09:42.710 --> 00:09:42.720 align:start position:0%
res search or bread for search reversal
 

00:09:42.720 --> 00:09:44.910 align:start position:0%
res search or bread for search reversal
we<00:09:42.839><c> just</c><00:09:43.000><c> do</c><00:09:43.240><c> a</c><00:09:43.399><c> sequential</c><00:09:43.920><c> pass</c><00:09:44.200><c> through</c>

00:09:44.910 --> 00:09:44.920 align:start position:0%
we just do a sequential pass through
 

00:09:44.920 --> 00:09:47.110 align:start position:0%
we just do a sequential pass through
through<00:09:45.120><c> the</c><00:09:45.240><c> code</c><00:09:45.680><c> uh</c><00:09:45.800><c> front</c><00:09:46.120><c> to</c><00:09:46.320><c> back</c><00:09:46.800><c> just</c><00:09:46.959><c> a</c>

00:09:47.110 --> 00:09:47.120 align:start position:0%
through the code uh front to back just a
 

00:09:47.120 --> 00:09:48.949 align:start position:0%
through the code uh front to back just a
simple<00:09:47.360><c> Loop</c><00:09:47.680><c> we</c><00:09:47.760><c> do</c><00:09:47.920><c> not</c><00:09:48.040><c> follow</c><00:09:48.360><c> jumps</c><00:09:48.800><c> when</c>

00:09:48.949 --> 00:09:48.959 align:start position:0%
simple Loop we do not follow jumps when
 

00:09:48.959 --> 00:09:53.069 align:start position:0%
simple Loop we do not follow jumps when
they<00:09:49.079><c> see</c><00:09:49.360><c> them</c><00:09:50.320><c> instead</c><00:09:51.079><c> we</c><00:09:52.079><c> handle</c><00:09:52.680><c> jumps</c>

00:09:53.069 --> 00:09:53.079 align:start position:0%
they see them instead we handle jumps
 

00:09:53.079 --> 00:09:54.430 align:start position:0%
they see them instead we handle jumps
differently<00:09:53.560><c> depending</c><00:09:54.000><c> whether</c><00:09:54.200><c> it's</c><00:09:54.320><c> a</c>

00:09:54.430 --> 00:09:54.440 align:start position:0%
differently depending whether it's a
 

00:09:54.440 --> 00:09:56.790 align:start position:0%
differently depending whether it's a
forward<00:09:54.800><c> jump</c><00:09:55.079><c> or</c><00:09:55.279><c> backwards</c><00:09:55.760><c> jump</c><00:09:56.480><c> uh</c><00:09:56.600><c> so</c>

00:09:56.790 --> 00:09:56.800 align:start position:0%
forward jump or backwards jump uh so
 

00:09:56.800 --> 00:09:59.110 align:start position:0%
forward jump or backwards jump uh so
depending<00:09:57.120><c> on</c><00:09:57.320><c> its</c><00:09:57.880><c> relative</c><00:09:58.279><c> offset</c><00:09:58.880><c> and</c>

00:09:59.110 --> 00:09:59.120 align:start position:0%
depending on its relative offset and
 

00:09:59.120 --> 00:10:01.230 align:start position:0%
depending on its relative offset and
this<00:09:59.480><c> is</c><00:09:59.640><c> known</c><00:10:00.000><c> at</c><00:10:00.200><c> validation</c><00:10:00.640><c> time</c><00:10:00.880><c> because</c>

00:10:01.230 --> 00:10:01.240 align:start position:0%
this is known at validation time because
 

00:10:01.240 --> 00:10:04.269 align:start position:0%
this is known at validation time because
EF<00:10:01.720><c> has</c><00:10:02.519><c> static</c><00:10:02.839><c> jumps</c><00:10:03.279><c> instead</c><00:10:03.519><c> of</c><00:10:03.640><c> dynamic</c>

00:10:04.269 --> 00:10:04.279 align:start position:0%
EF has static jumps instead of dynamic
 

00:10:04.279 --> 00:10:07.190 align:start position:0%
EF has static jumps instead of dynamic
jumps<00:10:05.279><c> so</c><00:10:05.720><c> we</c><00:10:05.920><c> look</c><00:10:06.120><c> at</c><00:10:06.240><c> this</c><00:10:06.399><c> offset</c><00:10:06.920><c> if</c><00:10:07.079><c> it's</c>

00:10:07.190 --> 00:10:07.200 align:start position:0%
jumps so we look at this offset if it's
 

00:10:07.200 --> 00:10:09.949 align:start position:0%
jumps so we look at this offset if it's
a<00:10:07.360><c> forward</c><00:10:07.760><c> jump</c><00:10:08.760><c> we</c><00:10:08.959><c> always</c><00:10:09.240><c> allow</c><00:10:09.560><c> it</c><00:10:09.680><c> and</c><00:10:09.800><c> we</c>

00:10:09.949 --> 00:10:09.959 align:start position:0%
a forward jump we always allow it and we
 

00:10:09.959 --> 00:10:11.590 align:start position:0%
a forward jump we always allow it and we
just<00:10:10.120><c> record</c><00:10:10.560><c> the</c><00:10:10.720><c> stack</c><00:10:11.040><c> height</c><00:10:11.279><c> at</c><00:10:11.399><c> the</c>

00:10:11.590 --> 00:10:11.600 align:start position:0%
just record the stack height at the
 

00:10:11.600 --> 00:10:13.829 align:start position:0%
just record the stack height at the
Target<00:10:12.200><c> uh</c>

00:10:13.829 --> 00:10:13.839 align:start position:0%
Target uh
 

00:10:13.839 --> 00:10:16.069 align:start position:0%
Target uh
instruction<00:10:14.839><c> if</c><00:10:14.959><c> we</c><00:10:15.120><c> have</c><00:10:15.360><c> already</c><00:10:15.640><c> visited</c>

00:10:16.069 --> 00:10:16.079 align:start position:0%
instruction if we have already visited
 

00:10:16.079 --> 00:10:18.389 align:start position:0%
instruction if we have already visited
this<00:10:16.560><c> uh</c><00:10:16.680><c> or</c><00:10:16.839><c> we</c><00:10:17.000><c> have</c><00:10:17.240><c> already</c><00:10:17.480><c> seen</c><00:10:17.880><c> this</c>

00:10:18.389 --> 00:10:18.399 align:start position:0%
this uh or we have already seen this
 

00:10:18.399 --> 00:10:20.310 align:start position:0%
this uh or we have already seen this
target<00:10:18.720><c> instruction</c><00:10:19.200><c> before</c><00:10:19.560><c> we</c><00:10:19.800><c> expand</c><00:10:20.200><c> the</c>

00:10:20.310 --> 00:10:20.320 align:start position:0%
target instruction before we expand the
 

00:10:20.320 --> 00:10:22.750 align:start position:0%
target instruction before we expand the
stack<00:10:20.640><c> height</c><00:10:20.959><c> range</c><00:10:21.240><c> of</c><00:10:21.399><c> the</c>

00:10:22.750 --> 00:10:22.760 align:start position:0%
stack height range of the
 

00:10:22.760 --> 00:10:25.310 align:start position:0%
stack height range of the
Target<00:10:23.760><c> and</c><00:10:24.040><c> this</c><00:10:24.200><c> specifically</c><00:10:24.680><c> fixes</c><00:10:25.040><c> our</c>

00:10:25.310 --> 00:10:25.320 align:start position:0%
Target and this specifically fixes our
 

00:10:25.320 --> 00:10:27.829 align:start position:0%
Target and this specifically fixes our
problematic<00:10:25.880><c> case</c>

00:10:27.829 --> 00:10:27.839 align:start position:0%
problematic case
 

00:10:27.839 --> 00:10:30.389 align:start position:0%
problematic case
um<00:10:28.839><c> we</c><00:10:29.040><c> always</c><00:10:29.440><c> allow</c><00:10:29.760><c> this</c><00:10:29.880><c> jumps</c><00:10:30.160><c> into</c><00:10:30.320><c> a</c>

00:10:30.389 --> 00:10:30.399 align:start position:0%
um we always allow this jumps into a
 

00:10:30.399 --> 00:10:33.870 align:start position:0%
um we always allow this jumps into a
common<00:10:30.920><c> code</c><00:10:31.360><c> and</c><00:10:31.839><c> thanks</c><00:10:32.120><c> to</c><00:10:32.760><c> sequential</c><00:10:33.760><c> uh</c>

00:10:33.870 --> 00:10:33.880 align:start position:0%
common code and thanks to sequential uh
 

00:10:33.880 --> 00:10:36.629 align:start position:0%
common code and thanks to sequential uh
traversal<00:10:34.560><c> of</c><00:10:34.720><c> The</c><00:10:34.959><c> Code</c><00:10:35.959><c> by</c><00:10:36.120><c> the</c><00:10:36.279><c> time</c><00:10:36.440><c> we</c>

00:10:36.629 --> 00:10:36.639 align:start position:0%
traversal of The Code by the time we
 

00:10:36.639 --> 00:10:38.509 align:start position:0%
traversal of The Code by the time we
reach<00:10:37.079><c> the</c><00:10:37.320><c> validation</c><00:10:37.800><c> of</c><00:10:38.000><c> this</c><00:10:38.240><c> common</c>

00:10:38.509 --> 00:10:38.519 align:start position:0%
reach the validation of this common
 

00:10:38.519 --> 00:10:40.350 align:start position:0%
reach the validation of this common
helper<00:10:38.920><c> we</c><00:10:39.040><c> have</c><00:10:39.200><c> already</c><00:10:39.440><c> seen</c><00:10:39.760><c> all</c><00:10:39.920><c> forward</c>

00:10:40.350 --> 00:10:40.360 align:start position:0%
helper we have already seen all forward
 

00:10:40.360 --> 00:10:42.069 align:start position:0%
helper we have already seen all forward
jumps<00:10:40.680><c> into</c><00:10:40.920><c> it</c><00:10:41.040><c> so</c><00:10:41.200><c> we</c><00:10:41.320><c> have</c><00:10:41.440><c> seen</c><00:10:41.720><c> already</c>

00:10:42.069 --> 00:10:42.079 align:start position:0%
jumps into it so we have seen already
 

00:10:42.079 --> 00:10:44.829 align:start position:0%
jumps into it so we have seen already
all<00:10:42.519><c> stack</c><00:10:42.920><c> Heights</c><00:10:43.920><c> uh</c><00:10:44.000><c> at</c><00:10:44.160><c> all</c><00:10:44.279><c> of</c><00:10:44.399><c> the</c><00:10:44.519><c> jumps</c>

00:10:44.829 --> 00:10:44.839 align:start position:0%
all stack Heights uh at all of the jumps
 

00:10:44.839 --> 00:10:47.350 align:start position:0%
all stack Heights uh at all of the jumps
into<00:10:45.040><c> this</c><00:10:45.279><c> common</c><00:10:45.920><c> uh</c><00:10:46.279><c> uh</c><00:10:46.440><c> code</c><00:10:46.839><c> and</c><00:10:47.040><c> then</c><00:10:47.160><c> we</c>

00:10:47.350 --> 00:10:47.360 align:start position:0%
into this common uh uh code and then we
 

00:10:47.360 --> 00:10:49.590 align:start position:0%
into this common uh uh code and then we
validate<00:10:47.680><c> it</c><00:10:47.839><c> using</c><00:10:48.160><c> this</c><00:10:48.760><c> uh</c><00:10:49.120><c> stack</c><00:10:49.440><c> height</c>

00:10:49.590 --> 00:10:49.600 align:start position:0%
validate it using this uh stack height
 

00:10:49.600 --> 00:10:51.870 align:start position:0%
validate it using this uh stack height
range<00:10:49.880><c> that</c><00:10:50.000><c> we</c><00:10:50.079><c> have</c><00:10:50.480><c> observed</c><00:10:51.480><c> so</c><00:10:51.680><c> this</c>

00:10:51.870 --> 00:10:51.880 align:start position:0%
range that we have observed so this
 

00:10:51.880 --> 00:10:55.350 align:start position:0%
range that we have observed so this
fixes<00:10:52.519><c> the</c><00:10:52.800><c> problem</c><00:10:53.279><c> and</c><00:10:53.839><c> um</c><00:10:54.440><c> as</c><00:10:54.600><c> for</c><00:10:54.839><c> backward</c>

00:10:55.350 --> 00:10:55.360 align:start position:0%
fixes the problem and um as for backward
 

00:10:55.360 --> 00:10:57.990 align:start position:0%
fixes the problem and um as for backward
jumps<00:10:56.160><c> uh</c><00:10:56.320><c> we</c><00:10:56.519><c> still</c><00:10:56.839><c> keep</c><00:10:57.120><c> the</c><00:10:57.240><c> exactly</c><00:10:57.639><c> same</c>

00:10:57.990 --> 00:10:58.000 align:start position:0%
jumps uh we still keep the exactly same
 

00:10:58.000 --> 00:11:00.030 align:start position:0%
jumps uh we still keep the exactly same
restriction<00:10:58.480><c> as</c><00:10:58.639><c> before</c><00:10:58.959><c> we</c><00:10:59.320><c> require</c><00:10:59.760><c> equal</c>

00:11:00.030 --> 00:11:00.040 align:start position:0%
restriction as before we require equal
 

00:11:00.040 --> 00:11:01.990 align:start position:0%
restriction as before we require equal
stack<00:11:00.360><c> height</c><00:11:00.600><c> at</c><00:11:00.720><c> the</c><00:11:00.839><c> jump</c><00:11:01.320><c> instruction</c><00:11:01.839><c> and</c>

00:11:01.990 --> 00:11:02.000 align:start position:0%
stack height at the jump instruction and
 

00:11:02.000 --> 00:11:05.150 align:start position:0%
stack height at the jump instruction and
at<00:11:02.120><c> the</c><00:11:02.240><c> target</c><00:11:02.480><c> of</c><00:11:02.600><c> a</c><00:11:02.920><c> jump</c><00:11:03.920><c> this</c><00:11:04.079><c> means</c><00:11:04.760><c> that</c>

00:11:05.150 --> 00:11:05.160 align:start position:0%
at the target of a jump this means that
 

00:11:05.160 --> 00:11:06.829 align:start position:0%
at the target of a jump this means that
Loops<00:11:05.600><c> that</c><00:11:05.760><c> grow</c><00:11:05.959><c> or</c><00:11:06.079><c> Shrink</c><00:11:06.399><c> stack</c><00:11:06.680><c> are</c>

00:11:06.829 --> 00:11:06.839 align:start position:0%
Loops that grow or Shrink stack are
 

00:11:06.839 --> 00:11:08.230 align:start position:0%
Loops that grow or Shrink stack are
still<00:11:07.040><c> not</c><00:11:07.320><c> allowed</c><00:11:07.760><c> this</c><00:11:07.839><c> is</c><00:11:08.040><c> pretty</c>

00:11:08.230 --> 00:11:08.240 align:start position:0%
still not allowed this is pretty
 

00:11:08.240 --> 00:11:10.590 align:start position:0%
still not allowed this is pretty
reasonable<00:11:08.639><c> restriction</c><00:11:09.040><c> to</c><00:11:09.240><c> keep</c><00:11:09.639><c> no</c>

00:11:10.590 --> 00:11:10.600 align:start position:0%
reasonable restriction to keep no
 

00:11:10.600 --> 00:11:12.870 align:start position:0%
reasonable restriction to keep no
compilers<00:11:11.320><c> generate</c><00:11:11.760><c> such</c><00:11:11.959><c> Loops</c><00:11:12.360><c> anyway</c><00:11:12.800><c> and</c>

00:11:12.870 --> 00:11:12.880 align:start position:0%
compilers generate such Loops anyway and
 

00:11:12.880 --> 00:11:16.350 align:start position:0%
compilers generate such Loops anyway and
so<00:11:13.079><c> they</c><00:11:13.200><c> are</c><00:11:13.360><c> fine</c><00:11:13.560><c> with</c><00:11:14.160><c> it</c><00:11:15.160><c> uh</c><00:11:15.480><c> if</c><00:11:16.120><c> this</c>

00:11:16.350 --> 00:11:16.360 align:start position:0%
so they are fine with it uh if this
 

00:11:16.360 --> 00:11:19.030 align:start position:0%
so they are fine with it uh if this
backwards<00:11:16.920><c> jump</c><00:11:17.360><c> is</c><00:11:17.800><c> in</c><00:11:18.079><c> fact</c><00:11:18.279><c> a</c><00:11:18.480><c> jump</c><00:11:18.720><c> into</c><00:11:18.920><c> a</c>

00:11:19.030 --> 00:11:19.040 align:start position:0%
backwards jump is in fact a jump into a
 

00:11:19.040 --> 00:11:23.509 align:start position:0%
backwards jump is in fact a jump into a
helper<00:11:19.440><c> not</c><00:11:19.639><c> a</c><00:11:20.200><c> loop</c><00:11:21.200><c> uh</c><00:11:21.600><c> it</c><00:11:22.320><c> um</c><00:11:22.839><c> this</c><00:11:23.040><c> code</c>

00:11:23.509 --> 00:11:23.519 align:start position:0%
helper not a loop uh it um this code
 

00:11:23.519 --> 00:11:25.750 align:start position:0%
helper not a loop uh it um this code
always<00:11:23.839><c> can</c><00:11:24.000><c> be</c><00:11:24.200><c> reordered</c><00:11:24.800><c> in</c><00:11:24.880><c> a</c><00:11:25.040><c> way</c><00:11:25.279><c> that</c>

00:11:25.750 --> 00:11:25.760 align:start position:0%
always can be reordered in a way that
 

00:11:25.760 --> 00:11:27.829 align:start position:0%
always can be reordered in a way that
jumps<00:11:26.120><c> into</c><00:11:26.320><c> a</c><00:11:26.440><c> helper</c><00:11:26.760><c> is</c><00:11:26.880><c> a</c><00:11:27.000><c> forward</c><00:11:27.399><c> jump</c><00:11:27.720><c> so</c>

00:11:27.829 --> 00:11:27.839 align:start position:0%
jumps into a helper is a forward jump so
 

00:11:27.839 --> 00:11:29.750 align:start position:0%
jumps into a helper is a forward jump so
this<00:11:27.959><c> is</c><00:11:28.120><c> kind</c><00:11:28.240><c> of</c><00:11:28.320><c> an</c><00:11:28.480><c> implicit</c><00:11:28.880><c> require</c><00:11:29.440><c> M</c><00:11:29.600><c> to</c>

00:11:29.750 --> 00:11:29.760 align:start position:0%
this is kind of an implicit require M to
 

00:11:29.760 --> 00:11:31.550 align:start position:0%
this is kind of an implicit require M to
put<00:11:29.959><c> on</c><00:11:30.120><c> the</c><00:11:30.279><c> code</c><00:11:30.480><c> ordering</c><00:11:30.920><c> for</c><00:11:31.079><c> compilers</c>

00:11:31.550 --> 00:11:31.560 align:start position:0%
put on the code ordering for compilers
 

00:11:31.560 --> 00:11:35.190 align:start position:0%
put on the code ordering for compilers
to<00:11:32.440><c> and</c><00:11:32.800><c> this</c><00:11:32.920><c> is</c><00:11:33.200><c> always</c><00:11:33.600><c> can</c><00:11:33.760><c> be</c><00:11:33.920><c> done</c><00:11:34.279><c> and</c><00:11:34.959><c> so</c>

00:11:35.190 --> 00:11:35.200 align:start position:0%
to and this is always can be done and so
 

00:11:35.200 --> 00:11:37.069 align:start position:0%
to and this is always can be done and so
compilers<00:11:35.839><c> are</c><00:11:36.000><c> fine</c><00:11:36.240><c> with</c>

00:11:37.069 --> 00:11:37.079 align:start position:0%
compilers are fine with
 

00:11:37.079 --> 00:11:39.550 align:start position:0%
compilers are fine with
this<00:11:38.079><c> if</c><00:11:38.200><c> we</c><00:11:38.320><c> see</c><00:11:38.519><c> a</c><00:11:38.800><c> regular</c><00:11:39.160><c> instruction</c>

00:11:39.550 --> 00:11:39.560 align:start position:0%
this if we see a regular instruction
 

00:11:39.560 --> 00:11:41.590 align:start position:0%
this if we see a regular instruction
which<00:11:39.680><c> is</c><00:11:39.800><c> not</c><00:11:39.920><c> a</c><00:11:40.040><c> jump</c><00:11:40.360><c> we</c><00:11:40.600><c> just</c><00:11:40.880><c> modify</c><00:11:41.399><c> both</c>

00:11:41.590 --> 00:11:41.600 align:start position:0%
which is not a jump we just modify both
 

00:11:41.600 --> 00:11:42.829 align:start position:0%
which is not a jump we just modify both
ends<00:11:41.800><c> of</c><00:11:41.920><c> the</c><00:11:42.040><c> stack</c><00:11:42.279><c> height</c><00:11:42.440><c> range</c><00:11:42.720><c> both</c>

00:11:42.829 --> 00:11:42.839 align:start position:0%
ends of the stack height range both
 

00:11:42.839 --> 00:11:43.949 align:start position:0%
ends of the stack height range both
minimum<00:11:43.160><c> and</c>

00:11:43.949 --> 00:11:43.959 align:start position:0%
minimum and
 

00:11:43.959 --> 00:11:46.670 align:start position:0%
minimum and
maximum<00:11:44.959><c> uh</c><00:11:45.120><c> stack</c><00:11:45.440><c> underflow</c><00:11:46.040><c> is</c><00:11:46.200><c> checked</c>

00:11:46.670 --> 00:11:46.680 align:start position:0%
maximum uh stack underflow is checked
 

00:11:46.680 --> 00:11:49.670 align:start position:0%
maximum uh stack underflow is checked
obviously<00:11:47.079><c> using</c><00:11:47.440><c> minimum</c><00:11:47.839><c> end</c><00:11:48.040><c> of</c><00:11:48.160><c> the</c><00:11:48.680><c> range</c>

00:11:49.670 --> 00:11:49.680 align:start position:0%
obviously using minimum end of the range
 

00:11:49.680 --> 00:11:52.069 align:start position:0%
obviously using minimum end of the range
and<00:11:50.040><c> one</c><00:11:50.320><c> extra</c><00:11:50.720><c> restriction</c><00:11:51.240><c> on</c><00:11:51.600><c> or</c><00:11:51.760><c> one</c>

00:11:52.069 --> 00:11:52.079 align:start position:0%
and one extra restriction on or one
 

00:11:52.079 --> 00:11:54.710 align:start position:0%
and one extra restriction on or one
change<00:11:52.440><c> in</c><00:11:52.680><c> how</c><00:11:52.839><c> we</c><00:11:53.000><c> Define</c><00:11:53.360><c> unreachable</c><00:11:53.920><c> code</c>

00:11:54.710 --> 00:11:54.720 align:start position:0%
change in how we Define unreachable code
 

00:11:54.720 --> 00:11:57.389 align:start position:0%
change in how we Define unreachable code
this<00:11:54.839><c> is</c><00:11:55.040><c> very</c><00:11:55.240><c> much</c><00:11:55.680><c> related</c><00:11:56.200><c> to</c><00:11:56.880><c> backwards</c>

00:11:57.389 --> 00:11:57.399 align:start position:0%
this is very much related to backwards
 

00:11:57.399 --> 00:11:59.230 align:start position:0%
this is very much related to backwards
jump<00:11:57.800><c> rule</c><00:11:58.120><c> that</c><00:11:58.240><c> I</c><00:11:58.320><c> have</c><00:11:58.480><c> already</c><00:11:58.920><c> mentioned</c>

00:11:59.230 --> 00:11:59.240 align:start position:0%
jump rule that I have already mentioned
 

00:11:59.240 --> 00:12:02.790 align:start position:0%
jump rule that I have already mentioned
mentioned<00:11:59.639><c> just</c><00:11:59.839><c> now</c><00:12:00.800><c> so</c><00:12:01.040><c> we</c><00:12:01.279><c> also</c><00:12:02.160><c> uh</c><00:12:02.440><c> expand</c>

00:12:02.790 --> 00:12:02.800 align:start position:0%
mentioned just now so we also uh expand
 

00:12:02.800 --> 00:12:04.110 align:start position:0%
mentioned just now so we also uh expand
a<00:12:02.920><c> bit</c><00:12:03.079><c> the</c><00:12:03.200><c> definition</c><00:12:03.560><c> of</c><00:12:03.720><c> what</c><00:12:03.839><c> is</c><00:12:03.959><c> UN</c>

00:12:04.110 --> 00:12:04.120 align:start position:0%
a bit the definition of what is UN
 

00:12:04.120 --> 00:12:06.110 align:start position:0%
a bit the definition of what is UN
reachable<00:12:04.440><c> code</c><00:12:04.720><c> if</c><00:12:04.839><c> some</c><00:12:05.079><c> code</c><00:12:05.360><c> is</c><00:12:05.519><c> reachable</c>

00:12:06.110 --> 00:12:06.120 align:start position:0%
reachable code if some code is reachable
 

00:12:06.120 --> 00:12:08.230 align:start position:0%
reachable code if some code is reachable
only<00:12:06.519><c> via</c><00:12:06.760><c> a</c><00:12:06.880><c> backwards</c><00:12:07.360><c> jump</c><00:12:07.760><c> we</c><00:12:07.959><c> also</c>

00:12:08.230 --> 00:12:08.240 align:start position:0%
only via a backwards jump we also
 

00:12:08.240 --> 00:12:10.190 align:start position:0%
only via a backwards jump we also
consider<00:12:08.560><c> it</c><00:12:08.680><c> unreachable</c><00:12:09.320><c> now</c><00:12:09.920><c> this</c><00:12:10.040><c> is</c>

00:12:10.190 --> 00:12:10.200 align:start position:0%
consider it unreachable now this is
 

00:12:10.200 --> 00:12:13.470 align:start position:0%
consider it unreachable now this is
needed<00:12:10.519><c> to</c><00:12:10.760><c> make</c><00:12:11.120><c> this</c><00:12:11.399><c> sequential</c><00:12:11.920><c> traversal</c>

00:12:13.470 --> 00:12:13.480 align:start position:0%
needed to make this sequential traversal
 

00:12:13.480 --> 00:12:16.710 align:start position:0%
needed to make this sequential traversal
possible<00:12:14.480><c> and</c><00:12:14.680><c> this</c><00:12:14.760><c> is</c><00:12:14.920><c> all</c><00:12:15.360><c> also</c><00:12:15.760><c> always</c><00:12:16.560><c> uh</c>

00:12:16.710 --> 00:12:16.720 align:start position:0%
possible and this is all also always uh
 

00:12:16.720 --> 00:12:19.310 align:start position:0%
possible and this is all also always uh
achievable<00:12:17.240><c> by</c><00:12:17.399><c> compilers</c><00:12:18.279><c> they</c><00:12:18.600><c> need</c><00:12:18.839><c> to</c><00:12:19.079><c> do</c>

00:12:19.310 --> 00:12:19.320 align:start position:0%
achievable by compilers they need to do
 

00:12:19.320 --> 00:12:21.150 align:start position:0%
achievable by compilers they need to do
some<00:12:19.560><c> kind</c><00:12:19.720><c> of</c><00:12:20.040><c> topological</c><00:12:20.519><c> sort</c><00:12:20.800><c> ordering</c>

00:12:21.150 --> 00:12:21.160 align:start position:0%
some kind of topological sort ordering
 

00:12:21.160 --> 00:12:24.310 align:start position:0%
some kind of topological sort ordering
of<00:12:21.360><c> the</c><00:12:21.839><c> basic</c><00:12:22.120><c> blocks</c><00:12:22.440><c> in</c><00:12:22.560><c> the</c><00:12:22.720><c> code</c><00:12:23.519><c> uh</c><00:12:23.800><c> and</c>

00:12:24.310 --> 00:12:24.320 align:start position:0%
of the basic blocks in the code uh and
 

00:12:24.320 --> 00:12:27.949 align:start position:0%
of the basic blocks in the code uh and
uh<00:12:24.800><c> it</c><00:12:24.959><c> always</c><00:12:25.199><c> can</c><00:12:25.360><c> be</c><00:12:25.839><c> done</c><00:12:26.839><c> uh</c><00:12:27.000><c> so</c><00:12:27.680><c> this</c>

00:12:27.949 --> 00:12:27.959 align:start position:0%
uh it always can be done uh so this
 

00:12:27.959 --> 00:12:30.189 align:start position:0%
uh it always can be done uh so this
restriction<00:12:28.399><c> is</c><00:12:28.519><c> fine</c><00:12:28.760><c> some</c><00:12:28.920><c> other</c><00:12:29.440><c> uh</c><00:12:29.720><c> VMS</c>

00:12:30.189 --> 00:12:30.199 align:start position:0%
restriction is fine some other uh VMS
 

00:12:30.199 --> 00:12:31.590 align:start position:0%
restriction is fine some other uh VMS
also<00:12:30.440><c> have</c><00:12:30.680><c> similar</c>

00:12:31.590 --> 00:12:31.600 align:start position:0%
also have similar
 

00:12:31.600 --> 00:12:36.470 align:start position:0%
also have similar
Rule<00:12:32.600><c> and</c><00:12:33.320><c> um</c><00:12:34.320><c> also</c><00:12:34.720><c> because</c><00:12:35.720><c> we</c><00:12:35.880><c> have</c><00:12:36.160><c> this</c>

00:12:36.470 --> 00:12:36.480 align:start position:0%
Rule and um also because we have this
 

00:12:36.480 --> 00:12:38.629 align:start position:0%
Rule and um also because we have this
simple<00:12:37.160><c> Loop</c><00:12:37.399><c> over</c><00:12:37.639><c> all</c><00:12:37.880><c> instructions</c><00:12:38.440><c> every</c>

00:12:38.629 --> 00:12:38.639 align:start position:0%
simple Loop over all instructions every
 

00:12:38.639 --> 00:12:40.269 align:start position:0%
simple Loop over all instructions every
instruction<00:12:39.000><c> is</c><00:12:39.160><c> visited</c><00:12:39.560><c> exactly</c><00:12:39.880><c> once</c><00:12:40.120><c> so</c>

00:12:40.269 --> 00:12:40.279 align:start position:0%
instruction is visited exactly once so
 

00:12:40.279 --> 00:12:41.790 align:start position:0%
instruction is visited exactly once so
we<00:12:40.360><c> are</c><00:12:40.519><c> still</c><00:12:40.720><c> fine</c><00:12:41.040><c> complexity</c><00:12:41.560><c> wise</c>

00:12:41.790 --> 00:12:41.800 align:start position:0%
we are still fine complexity wise
 

00:12:41.800 --> 00:12:43.189 align:start position:0%
we are still fine complexity wise
complexity<00:12:42.240><c> is</c><00:12:42.360><c> still</c>

00:12:43.189 --> 00:12:43.199 align:start position:0%
complexity is still
 

00:12:43.199 --> 00:12:45.389 align:start position:0%
complexity is still
linear<00:12:44.199><c> I'll</c><00:12:44.360><c> show</c><00:12:44.560><c> an</c><00:12:44.720><c> example</c><00:12:45.000><c> how</c><00:12:45.240><c> this</c>

00:12:45.389 --> 00:12:45.399 align:start position:0%
linear I'll show an example how this
 

00:12:45.399 --> 00:12:48.550 align:start position:0%
linear I'll show an example how this
would<00:12:45.600><c> work</c><00:12:46.160><c> now</c><00:12:47.160><c> uh</c><00:12:47.279><c> so</c><00:12:47.480><c> we'll</c><00:12:47.680><c> need</c><00:12:47.959><c> an</c><00:12:48.120><c> array</c>

00:12:48.550 --> 00:12:48.560 align:start position:0%
would work now uh so we'll need an array
 

00:12:48.560 --> 00:12:50.230 align:start position:0%
would work now uh so we'll need an array
of<00:12:48.760><c> two</c><00:12:48.959><c> arrays</c><00:12:49.320><c> of</c><00:12:49.480><c> minimum</c><00:12:49.800><c> and</c><00:12:49.920><c> maximum</c>

00:12:50.230 --> 00:12:50.240 align:start position:0%
of two arrays of minimum and maximum
 

00:12:50.240 --> 00:12:51.990 align:start position:0%
of two arrays of minimum and maximum
stack<00:12:50.560><c> height</c><00:12:50.760><c> or</c><00:12:50.920><c> array</c><00:12:51.199><c> of</c>

00:12:51.990 --> 00:12:52.000 align:start position:0%
stack height or array of
 

00:12:52.000 --> 00:12:54.509 align:start position:0%
stack height or array of
pairs<00:12:53.000><c> uh</c><00:12:53.240><c> note</c><00:12:53.519><c> that</c><00:12:53.680><c> we</c><00:12:53.760><c> do</c><00:12:53.880><c> not</c><00:12:54.000><c> need</c><00:12:54.160><c> a</c><00:12:54.279><c> work</c>

00:12:54.509 --> 00:12:54.519 align:start position:0%
pairs uh note that we do not need a work
 

00:12:54.519 --> 00:12:55.910 align:start position:0%
pairs uh note that we do not need a work
list<00:12:54.760><c> here</c><00:12:55.000><c> because</c><00:12:55.199><c> it's</c><00:12:55.360><c> just</c><00:12:55.480><c> a</c><00:12:55.639><c> simple</c>

00:12:55.910 --> 00:12:55.920 align:start position:0%
list here because it's just a simple
 

00:12:55.920 --> 00:12:58.470 align:start position:0%
list here because it's just a simple
Loop<00:12:56.560><c> uh</c><00:12:56.680><c> over</c><00:12:56.959><c> instructions</c><00:12:57.760><c> so</c><00:12:57.959><c> we</c><00:12:58.120><c> start</c>

00:12:58.470 --> 00:12:58.480 align:start position:0%
Loop uh over instructions so we start
 

00:12:58.480 --> 00:13:01.150 align:start position:0%
Loop uh over instructions so we start
with<00:12:58.600><c> the</c><00:12:58.760><c> first</c><00:12:58.959><c> one</c><00:12:59.440><c> push</c><00:13:00.320><c> uh</c><00:13:00.639><c> is</c><00:13:00.760><c> a</c><00:13:00.920><c> simple</c>

00:13:01.150 --> 00:13:01.160 align:start position:0%
with the first one push uh is a simple
 

00:13:01.160 --> 00:13:02.990 align:start position:0%
with the first one push uh is a simple
instruction<00:13:01.560><c> that</c><00:13:01.720><c> modifies</c><00:13:02.279><c> both</c><00:13:02.680><c> minimum</c>

00:13:02.990 --> 00:13:03.000 align:start position:0%
instruction that modifies both minimum
 

00:13:03.000 --> 00:13:06.590 align:start position:0%
instruction that modifies both minimum
and<00:13:03.160><c> maximum</c><00:13:03.519><c> so</c><00:13:03.720><c> 0</c><00:13:04.120><c> to0</c><00:13:04.680><c> becomes</c><00:13:05.199><c> 0</c><00:13:05.600><c> 1</c><00:13:05.760><c> to</c><00:13:05.920><c> one</c>

00:13:06.590 --> 00:13:06.600 align:start position:0%
and maximum so 0 to0 becomes 0 1 to one
 

00:13:06.600 --> 00:13:08.870 align:start position:0%
and maximum so 0 to0 becomes 0 1 to one
call<00:13:06.839><c> data</c><00:13:07.040><c> Lo</c><00:13:07.199><c> doesn't</c><00:13:07.440><c> change</c><00:13:07.680><c> it</c><00:13:08.279><c> then</c><00:13:08.519><c> this</c>

00:13:08.870 --> 00:13:08.880 align:start position:0%
call data Lo doesn't change it then this
 

00:13:08.880 --> 00:13:11.189 align:start position:0%
call data Lo doesn't change it then this
conditional<00:13:09.199><c> jump</c><00:13:10.199><c> uh</c><00:13:10.320><c> it</c><00:13:10.399><c> is</c><00:13:10.480><c> a</c><00:13:10.600><c> forward</c><00:13:10.959><c> jump</c>

00:13:11.189 --> 00:13:11.199 align:start position:0%
conditional jump uh it is a forward jump
 

00:13:11.199 --> 00:13:13.269 align:start position:0%
conditional jump uh it is a forward jump
so<00:13:11.320><c> it</c><00:13:11.440><c> is</c><00:13:11.519><c> a</c><00:13:11.639><c> load</c><00:13:12.199><c> and</c><00:13:12.399><c> we</c><00:13:12.560><c> have</c><00:13:12.920><c> just</c><00:13:13.079><c> to</c>

00:13:13.269 --> 00:13:13.279 align:start position:0%
so it is a load and we have just to
 

00:13:13.279 --> 00:13:15.470 align:start position:0%
so it is a load and we have just to
record<00:13:13.639><c> the</c><00:13:13.760><c> stack</c><00:13:14.079><c> height</c><00:13:14.440><c> at</c><00:13:14.560><c> the</c><00:13:14.800><c> Target</c><00:13:15.279><c> it</c>

00:13:15.470 --> 00:13:15.480 align:start position:0%
record the stack height at the Target it
 

00:13:15.480 --> 00:13:18.389 align:start position:0%
record the stack height at the Target it
is<00:13:15.880><c> zero</c><00:13:16.199><c> after</c><00:13:16.440><c> or</c><00:13:16.880><c> Pi</c><00:13:17.079><c> so</c><00:13:17.240><c> we</c><00:13:17.519><c> record</c><00:13:17.880><c> 0</c><00:13:18.199><c> to</c>

00:13:18.389 --> 00:13:18.399 align:start position:0%
is zero after or Pi so we record 0 to
 

00:13:18.399 --> 00:13:21.069 align:start position:0%
is zero after or Pi so we record 0 to
zero<00:13:18.720><c> at</c><00:13:18.959><c> offset</c>

00:13:21.069 --> 00:13:21.079 align:start position:0%
zero at offset
 

00:13:21.079 --> 00:13:25.030 align:start position:0%
zero at offset
X<00:13:22.120><c> um</c><00:13:23.120><c> uh</c><00:13:23.480><c> then</c><00:13:23.600><c> we</c><00:13:23.760><c> continue</c><00:13:24.120><c> with</c><00:13:24.240><c> the</c><00:13:24.760><c> next</c>

00:13:25.030 --> 00:13:25.040 align:start position:0%
X um uh then we continue with the next
 

00:13:25.040 --> 00:13:27.790 align:start position:0%
X um uh then we continue with the next
instruction<00:13:25.920><c> this</c><00:13:26.079><c> is</c><00:13:26.680><c> yeah</c><00:13:26.839><c> another</c><00:13:27.519><c> push</c>

00:13:27.790 --> 00:13:27.800 align:start position:0%
instruction this is yeah another push
 

00:13:27.800 --> 00:13:30.710 align:start position:0%
instruction this is yeah another push
and<00:13:28.079><c> push</c><00:13:28.480><c> and</c><00:13:28.760><c> C</c><00:13:29.240><c> Lo</c><00:13:29.560><c> and</c><00:13:30.000><c> then</c><00:13:30.240><c> another</c>

00:13:30.710 --> 00:13:30.720 align:start position:0%
and push and C Lo and then another
 

00:13:30.720 --> 00:13:33.389 align:start position:0%
and push and C Lo and then another
conditional<00:13:31.000><c> jump</c><00:13:31.279><c> that</c><00:13:31.440><c> targets</c><00:13:32.040><c> the</c><00:13:32.399><c> same</c>

00:13:33.389 --> 00:13:33.399 align:start position:0%
conditional jump that targets the same
 

00:13:33.399 --> 00:13:35.269 align:start position:0%
conditional jump that targets the same
offset<00:13:33.760><c> that</c><00:13:33.880><c> we</c><00:13:34.000><c> have</c><00:13:34.160><c> already</c><00:13:34.440><c> seen</c><00:13:34.800><c> before</c>

00:13:35.269 --> 00:13:35.279 align:start position:0%
offset that we have already seen before
 

00:13:35.279 --> 00:13:37.629 align:start position:0%
offset that we have already seen before
at<00:13:35.480><c> this</c><00:13:35.720><c> point</c><00:13:36.440><c> uh</c><00:13:36.600><c> stack</c><00:13:36.959><c> height</c><00:13:37.199><c> is</c><00:13:37.360><c> one</c>

00:13:37.629 --> 00:13:37.639 align:start position:0%
at this point uh stack height is one
 

00:13:37.639 --> 00:13:40.790 align:start position:0%
at this point uh stack height is one
after<00:13:37.880><c> R</c><00:13:38.079><c> jum</c><00:13:38.399><c> pi</c><00:13:39.240><c> and</c><00:13:39.440><c> we</c><00:13:39.720><c> have</c><00:13:39.920><c> to</c><00:13:40.480><c> at</c><00:13:40.639><c> this</c>

00:13:40.790 --> 00:13:40.800 align:start position:0%
after R jum pi and we have to at this
 

00:13:40.800 --> 00:13:42.590 align:start position:0%
after R jum pi and we have to at this
point<00:13:41.160><c> expand</c><00:13:41.560><c> the</c><00:13:41.720><c> stack</c><00:13:41.959><c> height</c><00:13:42.160><c> range</c><00:13:42.440><c> that</c>

00:13:42.590 --> 00:13:42.600 align:start position:0%
point expand the stack height range that
 

00:13:42.600 --> 00:13:44.949 align:start position:0%
point expand the stack height range that
we<00:13:42.720><c> have</c><00:13:42.880><c> seen</c><00:13:43.440><c> at</c><00:13:43.560><c> the</c><00:13:43.720><c> Target</c><00:13:44.079><c> before</c><00:13:44.320><c> so</c><00:13:44.440><c> 0</c><00:13:44.720><c> 0</c>

00:13:44.949 --> 00:13:44.959 align:start position:0%
we have seen at the Target before so 0 0
 

00:13:44.959 --> 00:13:47.629 align:start position:0%
we have seen at the Target before so 0 0
becomes<00:13:45.360><c> 01</c><00:13:46.360><c> then</c><00:13:46.519><c> we</c><00:13:46.680><c> have</c><00:13:46.800><c> a</c><00:13:47.000><c> stop</c><00:13:47.360><c> with</c><00:13:47.480><c> an</c>

00:13:47.629 --> 00:13:47.639 align:start position:0%
becomes 01 then we have a stop with an
 

00:13:47.639 --> 00:13:50.230 align:start position:0%
becomes 01 then we have a stop with an
extra<00:13:48.040><c> value</c><00:13:49.040><c> on</c><00:13:49.160><c> the</c><00:13:49.320><c> stack</c><00:13:49.600><c> this</c><00:13:49.680><c> is</c><00:13:49.800><c> allowed</c>

00:13:50.230 --> 00:13:50.240 align:start position:0%
extra value on the stack this is allowed
 

00:13:50.240 --> 00:13:52.189 align:start position:0%
extra value on the stack this is allowed
and<00:13:50.480><c> valid</c><00:13:50.839><c> and</c><00:13:50.959><c> then</c><00:13:51.079><c> we</c><00:13:51.240><c> get</c><00:13:51.399><c> to</c><00:13:51.600><c> this</c><00:13:51.759><c> Branch</c>

00:13:52.189 --> 00:13:52.199 align:start position:0%
and valid and then we get to this Branch
 

00:13:52.199 --> 00:13:53.990 align:start position:0%
and valid and then we get to this Branch
this<00:13:52.320><c> is</c><00:13:52.800><c> interesting</c><00:13:53.320><c> Branch</c><00:13:53.639><c> because</c><00:13:53.839><c> it</c>

00:13:53.990 --> 00:13:54.000 align:start position:0%
this is interesting Branch because it
 

00:13:54.000 --> 00:13:55.749 align:start position:0%
this is interesting Branch because it
has<00:13:54.279><c> multiple</c><00:13:54.720><c> possible</c><00:13:55.000><c> St</c><00:13:55.320><c> Heights</c><00:13:55.519><c> it</c><00:13:55.639><c> can</c>

00:13:55.749 --> 00:13:55.759 align:start position:0%
has multiple possible St Heights it can
 

00:13:55.759 --> 00:13:58.110 align:start position:0%
has multiple possible St Heights it can
be<00:13:55.920><c> either</c><00:13:56.160><c> zero</c><00:13:56.399><c> or</c><00:13:56.600><c> one</c><00:13:56.920><c> here</c><00:13:57.560><c> then</c><00:13:57.800><c> push</c>

00:13:58.110 --> 00:13:58.120 align:start position:0%
be either zero or one here then push
 

00:13:58.120 --> 00:13:59.910 align:start position:0%
be either zero or one here then push
would<00:13:58.320><c> modify</c><00:13:58.680><c> both</c><00:13:59.079><c> minimum</c><00:13:59.320><c> and</c><00:13:59.440><c> maximum</c><00:13:59.800><c> so</c>

00:13:59.910 --> 00:13:59.920 align:start position:0%
would modify both minimum and maximum so
 

00:13:59.920 --> 00:14:02.790 align:start position:0%
would modify both minimum and maximum so
it<00:14:00.000><c> shifts</c><00:14:00.600><c> the</c><00:14:00.800><c> St</c><00:14:01.120><c> height</c><00:14:01.320><c> range</c><00:14:02.040><c> 01</c><00:14:02.519><c> becomes</c>

00:14:02.790 --> 00:14:02.800 align:start position:0%
it shifts the St height range 01 becomes
 

00:14:02.800 --> 00:14:04.990 align:start position:0%
it shifts the St height range 01 becomes
one<00:14:03.000><c> two</c><00:14:03.320><c> and</c><00:14:03.519><c> another</c><00:14:03.839><c> push</c><00:14:04.360><c> and</c><00:14:04.519><c> revert</c>

00:14:04.990 --> 00:14:05.000 align:start position:0%
one two and another push and revert
 

00:14:05.000 --> 00:14:06.590 align:start position:0%
one two and another push and revert
checks<00:14:05.279><c> for</c><00:14:05.560><c> possible</c>

00:14:06.590 --> 00:14:06.600 align:start position:0%
checks for possible
 

00:14:06.600 --> 00:14:11.430 align:start position:0%
checks for possible
underflow<00:14:07.600><c> uh</c><00:14:08.680><c> uh</c><00:14:09.680><c> using</c><00:14:10.079><c> minimum</c><00:14:10.800><c> and</c><00:14:10.959><c> two</c><00:14:11.240><c> is</c>

00:14:11.430 --> 00:14:11.440 align:start position:0%
underflow uh uh using minimum and two is
 

00:14:11.440 --> 00:14:12.829 align:start position:0%
underflow uh uh using minimum and two is
exactly<00:14:11.720><c> what</c><00:14:11.880><c> revert</c><00:14:12.199><c> needs</c><00:14:12.480><c> so</c><00:14:12.680><c> no</c>

00:14:12.829 --> 00:14:12.839 align:start position:0%
exactly what revert needs so no
 

00:14:12.839 --> 00:14:14.550 align:start position:0%
exactly what revert needs so no
underflow<00:14:13.279><c> happens</c><00:14:13.639><c> this</c><00:14:13.759><c> code</c><00:14:14.000><c> is</c><00:14:14.199><c> valid</c><00:14:14.480><c> in</c>

00:14:14.550 --> 00:14:14.560 align:start position:0%
underflow happens this code is valid in
 

00:14:14.560 --> 00:14:17.230 align:start position:0%
underflow happens this code is valid in
the<00:14:14.680><c> end</c><00:14:14.920><c> this</c><00:14:15.120><c> concludes</c><00:14:15.560><c> the</c><00:14:16.079><c> validation</c><00:14:17.079><c> uh</c>

00:14:17.230 --> 00:14:17.240 align:start position:0%
the end this concludes the validation uh
 

00:14:17.240 --> 00:14:18.910 align:start position:0%
the end this concludes the validation uh
note<00:14:17.480><c> that</c><00:14:17.639><c> this</c><00:14:17.759><c> code</c><00:14:18.040><c> is</c><00:14:18.199><c> very</c><00:14:18.360><c> similar</c><00:14:18.720><c> to</c>

00:14:18.910 --> 00:14:18.920 align:start position:0%
note that this code is very similar to
 

00:14:18.920 --> 00:14:20.870 align:start position:0%
note that this code is very similar to
the<00:14:19.079><c> problematic</c><00:14:19.639><c> case</c><00:14:20.199><c> uh</c><00:14:20.279><c> that</c><00:14:20.399><c> I</c><00:14:20.480><c> showed</c><00:14:20.759><c> a</c>

00:14:20.870 --> 00:14:20.880 align:start position:0%
the problematic case uh that I showed a
 

00:14:20.880 --> 00:14:23.110 align:start position:0%
the problematic case uh that I showed a
couple<00:14:21.079><c> of</c><00:14:21.160><c> slides</c><00:14:21.519><c> before</c><00:14:22.320><c> this</c><00:14:22.440><c> is</c><00:14:22.680><c> like</c><00:14:22.839><c> a</c>

00:14:23.110 --> 00:14:23.120 align:start position:0%
couple of slides before this is like a
 

00:14:23.120 --> 00:14:25.030 align:start position:0%
couple of slides before this is like a
common<00:14:23.600><c> helper</c><00:14:24.040><c> that</c><00:14:24.160><c> reverts</c><00:14:24.560><c> and</c><00:14:24.720><c> a</c><00:14:24.839><c> couple</c>

00:14:25.030 --> 00:14:25.040 align:start position:0%
common helper that reverts and a couple
 

00:14:25.040 --> 00:14:26.509 align:start position:0%
common helper that reverts and a couple
of<00:14:25.160><c> jumps</c><00:14:25.560><c> from</c><00:14:25.759><c> different</c><00:14:26.000><c> stack</c><00:14:26.279><c> Heights</c>

00:14:26.509 --> 00:14:26.519 align:start position:0%
of jumps from different stack Heights
 

00:14:26.519 --> 00:14:27.269 align:start position:0%
of jumps from different stack Heights
into

00:14:27.269 --> 00:14:27.279 align:start position:0%
into
 

00:14:27.279 --> 00:14:30.189 align:start position:0%
into
it<00:14:28.279><c> uh</c><00:14:28.399><c> so</c><00:14:28.600><c> given</c><00:14:28.800><c> this</c><00:14:29.120><c> algorithm</c><00:14:30.040><c> uh</c>

00:14:30.189 --> 00:14:30.199 align:start position:0%
it uh so given this algorithm uh
 

00:14:30.199 --> 00:14:32.629 align:start position:0%
it uh so given this algorithm uh
concludes<00:14:31.120><c> successfully</c><00:14:32.120><c> uh</c><00:14:32.320><c> we</c><00:14:32.440><c> are</c>

00:14:32.629 --> 00:14:32.639 align:start position:0%
concludes successfully uh we are
 

00:14:32.639 --> 00:14:34.670 align:start position:0%
concludes successfully uh we are
guaranteed<00:14:33.160><c> that</c><00:14:33.279><c> no</c><00:14:33.440><c> underflows</c><00:14:34.199><c> happen</c><00:14:34.519><c> at</c>

00:14:34.670 --> 00:14:34.680 align:start position:0%
guaranteed that no underflows happen at
 

00:14:34.680 --> 00:14:37.790 align:start position:0%
guaranteed that no underflows happen at
run<00:14:35.079><c> time</c><00:14:35.720><c> uh</c><00:14:35.880><c> ever</c><00:14:36.240><c> at</c><00:14:36.360><c> all</c><00:14:37.040><c> uh</c><00:14:37.279><c> and</c><00:14:37.440><c> we</c><00:14:37.560><c> can</c>

00:14:37.790 --> 00:14:37.800 align:start position:0%
run time uh ever at all uh and we can
 

00:14:37.800 --> 00:14:39.269 align:start position:0%
run time uh ever at all uh and we can
completely<00:14:38.240><c> Amit</c><00:14:38.639><c> them</c><00:14:38.959><c> from</c><00:14:39.160><c> the</c>

00:14:39.269 --> 00:14:39.279 align:start position:0%
completely Amit them from the
 

00:14:39.279 --> 00:14:41.590 align:start position:0%
completely Amit them from the
interpreted<00:14:39.800><c> Loop</c><00:14:40.800><c> this</c><00:14:40.880><c> is</c><00:14:41.040><c> not</c><00:14:41.240><c> the</c><00:14:41.399><c> case</c>

00:14:41.590 --> 00:14:41.600 align:start position:0%
interpreted Loop this is not the case
 

00:14:41.600 --> 00:14:43.910 align:start position:0%
interpreted Loop this is not the case
with<00:14:41.759><c> overflow</c><00:14:42.399><c> checks</c><00:14:42.959><c> uh</c><00:14:43.040><c> we</c><00:14:43.160><c> cannot</c><00:14:43.560><c> remove</c>

00:14:43.910 --> 00:14:43.920 align:start position:0%
with overflow checks uh we cannot remove
 

00:14:43.920 --> 00:14:46.710 align:start position:0%
with overflow checks uh we cannot remove
them<00:14:44.399><c> uh</c><00:14:44.720><c> completely</c><00:14:45.720><c> but</c><00:14:45.920><c> we</c><00:14:46.040><c> can</c><00:14:46.240><c> minimize</c>

00:14:46.710 --> 00:14:46.720 align:start position:0%
them uh completely but we can minimize
 

00:14:46.720 --> 00:14:48.670 align:start position:0%
them uh completely but we can minimize
how<00:14:46.920><c> often</c><00:14:47.160><c> we</c><00:14:47.320><c> do</c><00:14:47.480><c> them</c><00:14:47.639><c> and</c><00:14:47.800><c> not</c><00:14:48.040><c> do</c><00:14:48.240><c> them</c><00:14:48.440><c> for</c>

00:14:48.670 --> 00:14:48.680 align:start position:0%
how often we do them and not do them for
 

00:14:48.680 --> 00:14:51.990 align:start position:0%
how often we do them and not do them for
every<00:14:49.240><c> instruction</c><00:14:50.240><c> as</c><00:14:50.440><c> current</c><00:14:50.720><c> evm</c>

00:14:51.990 --> 00:14:52.000 align:start position:0%
every instruction as current evm
 

00:14:52.000 --> 00:14:57.629 align:start position:0%
every instruction as current evm
does<00:14:53.000><c> uh</c><00:14:53.240><c> so</c><00:14:53.639><c> to</c><00:14:53.839><c> make</c><00:14:54.759><c> this</c><00:14:55.759><c> uh</c><00:14:56.600><c> work</c><00:14:57.000><c> we</c><00:14:57.199><c> start</c>

00:14:57.629 --> 00:14:57.639 align:start position:0%
does uh so to make this uh work we start
 

00:14:57.639 --> 00:15:01.189 align:start position:0%
does uh so to make this uh work we start
with<00:14:58.040><c> the</c><00:14:58.560><c> with</c><00:14:58.759><c> what</c><00:14:59.399><c> previous</c><00:15:00.199><c> underflows</c>

00:15:01.189 --> 00:15:01.199 align:start position:0%
with the with what previous underflows
 

00:15:01.199 --> 00:15:03.269 align:start position:0%
with the with what previous underflows
uh<00:15:01.480><c> validation</c><00:15:01.959><c> algorithm</c><00:15:02.440><c> gave</c><00:15:02.600><c> us</c><00:15:03.120><c> we</c>

00:15:03.269 --> 00:15:03.279 align:start position:0%
uh validation algorithm gave us we
 

00:15:03.279 --> 00:15:04.550 align:start position:0%
uh validation algorithm gave us we
recorded<00:15:03.759><c> stack</c><00:15:04.040><c> height</c><00:15:04.240><c> at</c><00:15:04.320><c> every</c>

00:15:04.550 --> 00:15:04.560 align:start position:0%
recorded stack height at every
 

00:15:04.560 --> 00:15:06.470 align:start position:0%
recorded stack height at every
instruction<00:15:05.079><c> in</c><00:15:05.279><c> this</c><00:15:05.440><c> algorithm</c><00:15:06.040><c> and</c><00:15:06.160><c> we</c><00:15:06.279><c> can</c>

00:15:06.470 --> 00:15:06.480 align:start position:0%
instruction in this algorithm and we can
 

00:15:06.480 --> 00:15:08.670 align:start position:0%
instruction in this algorithm and we can
just<00:15:07.000><c> find</c><00:15:07.360><c> maximum</c><00:15:07.800><c> of</c><00:15:07.959><c> these</c><00:15:08.120><c> stack</c><00:15:08.399><c> Heights</c>

00:15:08.670 --> 00:15:08.680 align:start position:0%
just find maximum of these stack Heights
 

00:15:08.680 --> 00:15:11.230 align:start position:0%
just find maximum of these stack Heights
and<00:15:08.880><c> this</c><00:15:09.160><c> value</c><00:15:09.560><c> value</c><00:15:09.880><c> is</c><00:15:10.040><c> going</c><00:15:10.240><c> to</c><00:15:10.399><c> mean</c>

00:15:11.230 --> 00:15:11.240 align:start position:0%
and this value value is going to mean
 

00:15:11.240 --> 00:15:13.189 align:start position:0%
and this value value is going to mean
maximum<00:15:11.680><c> stack</c><00:15:12.000><c> height</c><00:15:12.320><c> value</c><00:15:12.720><c> of</c><00:15:13.000><c> this</c>

00:15:13.189 --> 00:15:13.199 align:start position:0%
maximum stack height value of this
 

00:15:13.199 --> 00:15:16.030 align:start position:0%
maximum stack height value of this
functions<00:15:14.120><c> frame</c><00:15:15.120><c> if</c><00:15:15.279><c> this</c><00:15:15.440><c> value</c><00:15:15.680><c> is</c><00:15:15.800><c> above</c>

00:15:16.030 --> 00:15:16.040 align:start position:0%
functions frame if this value is above
 

00:15:16.040 --> 00:15:17.990 align:start position:0%
functions frame if this value is above
stack<00:15:16.279><c> height</c><00:15:16.480><c> limit</c><00:15:16.759><c> it</c><00:15:16.880><c> means</c><00:15:17.440><c> execution</c><00:15:17.839><c> of</c>

00:15:17.990 --> 00:15:18.000 align:start position:0%
stack height limit it means execution of
 

00:15:18.000 --> 00:15:19.910 align:start position:0%
stack height limit it means execution of
this<00:15:18.160><c> function</c><00:15:18.519><c> May</c><00:15:18.800><c> overflow</c><00:15:19.279><c> and</c><00:15:19.440><c> we</c><00:15:19.600><c> reject</c>

00:15:19.910 --> 00:15:19.920 align:start position:0%
this function May overflow and we reject
 

00:15:19.920 --> 00:15:21.470 align:start position:0%
this function May overflow and we reject
it<00:15:20.079><c> immediately</c><00:15:20.519><c> at</c><00:15:20.680><c> validation</c><00:15:21.079><c> we</c><00:15:21.199><c> do</c><00:15:21.320><c> not</c>

00:15:21.470 --> 00:15:21.480 align:start position:0%
it immediately at validation we do not
 

00:15:21.480 --> 00:15:24.230 align:start position:0%
it immediately at validation we do not
allow<00:15:21.720><c> it</c><00:15:21.920><c> to</c><00:15:22.040><c> be</c><00:15:22.639><c> deployed</c><00:15:23.639><c> uh</c><00:15:23.759><c> if</c><00:15:23.920><c> it</c><00:15:24.079><c> is</c>

00:15:24.230 --> 00:15:24.240 align:start position:0%
allow it to be deployed uh if it is
 

00:15:24.240 --> 00:15:25.910 align:start position:0%
allow it to be deployed uh if it is
within<00:15:24.480><c> the</c><00:15:24.600><c> limit</c><00:15:24.839><c> we</c><00:15:25.040><c> record</c><00:15:25.399><c> this</c><00:15:25.560><c> maximum</c>

00:15:25.910 --> 00:15:25.920 align:start position:0%
within the limit we record this maximum
 

00:15:25.920 --> 00:15:28.269 align:start position:0%
within the limit we record this maximum
stack<00:15:26.160><c> height</c><00:15:26.399><c> value</c><00:15:26.759><c> in</c><00:15:27.040><c> this</c><00:15:27.759><c> functions</c>

00:15:28.269 --> 00:15:28.279 align:start position:0%
stack height value in this functions
 

00:15:28.279 --> 00:15:30.389 align:start position:0%
stack height value in this functions
metadata<00:15:29.079><c> the</c><00:15:29.160><c> EF</c><00:15:29.519><c> header</c><00:15:29.920><c> and</c><00:15:30.079><c> then</c><00:15:30.240><c> this</c>

00:15:30.389 --> 00:15:30.399 align:start position:0%
metadata the EF header and then this
 

00:15:30.399 --> 00:15:32.309 align:start position:0%
metadata the EF header and then this
value<00:15:30.639><c> is</c><00:15:30.759><c> used</c><00:15:30.959><c> for</c><00:15:31.199><c> validating</c><00:15:31.680><c> the</c><00:15:31.839><c> calls</c>

00:15:32.309 --> 00:15:32.319 align:start position:0%
value is used for validating the calls
 

00:15:32.319 --> 00:15:35.430 align:start position:0%
value is used for validating the calls
into<00:15:32.600><c> this</c><00:15:33.120><c> section</c><00:15:34.120><c> and</c><00:15:34.360><c> also</c><00:15:34.680><c> at</c><00:15:34.920><c> execution</c>

00:15:35.430 --> 00:15:35.440 align:start position:0%
into this section and also at execution
 

00:15:35.440 --> 00:15:37.470 align:start position:0%
into this section and also at execution
time<00:15:35.639><c> when</c><00:15:35.759><c> we</c><00:15:35.920><c> execute</c><00:15:36.399><c> call</c><00:15:36.639><c> F</c><00:15:36.839><c> for</c><00:15:37.000><c> jump</c><00:15:37.240><c> F</c>

00:15:37.470 --> 00:15:37.480 align:start position:0%
time when we execute call F for jump F
 

00:15:37.480 --> 00:15:40.590 align:start position:0%
time when we execute call F for jump F
into<00:15:37.800><c> this</c><00:15:38.319><c> uh</c><00:15:38.560><c> function</c><00:15:39.040><c> so</c><00:15:40.000><c> in</c><00:15:40.120><c> the</c><00:15:40.240><c> end</c><00:15:40.440><c> we</c>

00:15:40.590 --> 00:15:40.600 align:start position:0%
into this uh function so in the end we
 

00:15:40.600 --> 00:15:42.910 align:start position:0%
into this uh function so in the end we
only<00:15:41.000><c> have</c><00:15:41.120><c> to</c><00:15:41.319><c> do</c><00:15:41.600><c> runtime</c><00:15:42.040><c> overflow</c><00:15:42.519><c> checks</c>

00:15:42.910 --> 00:15:42.920 align:start position:0%
only have to do runtime overflow checks
 

00:15:42.920 --> 00:15:46.389 align:start position:0%
only have to do runtime overflow checks
at<00:15:43.639><c> two</c><00:15:44.639><c> uh</c><00:15:44.800><c> locations</c><00:15:45.199><c> in</c><00:15:45.360><c> the</c><00:15:45.480><c> code</c><00:15:45.800><c> for</c><00:15:46.279><c> when</c>

00:15:46.389 --> 00:15:46.399 align:start position:0%
at two uh locations in the code for when
 

00:15:46.399 --> 00:15:49.069 align:start position:0%
at two uh locations in the code for when
we<00:15:46.519><c> execute</c><00:15:46.839><c> call</c><00:15:47.040><c> F</c><00:15:47.199><c> or</c><00:15:47.319><c> jump</c><00:15:47.600><c> F</c><00:15:47.920><c> we</c><00:15:48.319><c> get</c><00:15:48.720><c> the</c>

00:15:49.069 --> 00:15:49.079 align:start position:0%
we execute call F or jump F we get the
 

00:15:49.079 --> 00:15:50.829 align:start position:0%
we execute call F or jump F we get the
current<00:15:49.399><c> runtime</c><00:15:49.759><c> stack</c><00:15:50.079><c> height</c><00:15:50.360><c> we</c><00:15:50.519><c> add</c><00:15:50.680><c> it</c>

00:15:50.829 --> 00:15:50.839 align:start position:0%
current runtime stack height we add it
 

00:15:50.839 --> 00:15:54.670 align:start position:0%
current runtime stack height we add it
up<00:15:51.120><c> with</c><00:15:51.720><c> maximum</c><00:15:52.199><c> stack</c><00:15:52.639><c> height</c><00:15:52.959><c> of</c><00:15:53.120><c> the</c>

00:15:54.670 --> 00:15:54.680 align:start position:0%
up with maximum stack height of the
 

00:15:54.680 --> 00:15:57.150 align:start position:0%
up with maximum stack height of the
call<00:15:55.680><c> if</c><00:15:55.880><c> this</c><00:15:56.000><c> sum</c><00:15:56.240><c> is</c><00:15:56.399><c> above</c><00:15:56.639><c> the</c><00:15:56.880><c> stack</c>

00:15:57.150 --> 00:15:57.160 align:start position:0%
call if this sum is above the stack
 

00:15:57.160 --> 00:15:58.590 align:start position:0%
call if this sum is above the stack
height<00:15:57.319><c> limit</c><00:15:57.560><c> we</c><00:15:57.639><c> do</c><00:15:57.800><c> not</c><00:15:57.920><c> allow</c><00:15:58.160><c> callif</c><00:15:58.480><c> a</c>

00:15:58.590 --> 00:15:58.600 align:start position:0%
height limit we do not allow callif a
 

00:15:58.600 --> 00:16:01.269 align:start position:0%
height limit we do not allow callif a
jump<00:15:59.040><c> we</c><00:15:59.199><c> exceptionally</c><00:15:59.800><c> abort</c><00:16:00.240><c> at</c><00:16:00.560><c> call</c><00:16:00.839><c> F</c><00:16:01.079><c> or</c>

00:16:01.269 --> 00:16:01.279 align:start position:0%
jump we exceptionally abort at call F or
 

00:16:01.279 --> 00:16:06.470 align:start position:0%
jump we exceptionally abort at call F or
jump<00:16:01.839><c> F</c><00:16:02.839><c> otherwise</c><00:16:03.680><c> uh</c><00:16:04.560><c> um</c><00:16:05.560><c> execution</c><00:16:06.199><c> could</c>

00:16:06.470 --> 00:16:06.480 align:start position:0%
jump F otherwise uh um execution could
 

00:16:06.480 --> 00:16:09.150 align:start position:0%
jump F otherwise uh um execution could
overflow<00:16:07.079><c> execution</c><00:16:07.480><c> of</c><00:16:07.680><c> this</c><00:16:08.240><c> uh</c><00:16:08.720><c> eof</c>

00:16:09.150 --> 00:16:09.160 align:start position:0%
overflow execution of this uh eof
 

00:16:09.160 --> 00:16:11.710 align:start position:0%
overflow execution of this uh eof
function<00:16:10.079><c> so</c><00:16:10.279><c> this</c><00:16:10.399><c> is</c><00:16:10.560><c> how</c><00:16:10.759><c> overflows</c><00:16:11.440><c> are</c>

00:16:11.710 --> 00:16:11.720 align:start position:0%
function so this is how overflows are
 

00:16:11.720 --> 00:16:14.150 align:start position:0%
function so this is how overflows are
handled<00:16:12.279><c> and</c><00:16:12.720><c> uh</c><00:16:13.199><c> one</c><00:16:13.440><c> final</c><00:16:13.759><c> thing</c><00:16:13.920><c> that</c><00:16:14.040><c> I</c>

00:16:14.150 --> 00:16:14.160 align:start position:0%
handled and uh one final thing that I
 

00:16:14.160 --> 00:16:16.230 align:start position:0%
handled and uh one final thing that I
wanted<00:16:14.399><c> to</c><00:16:14.519><c> mention</c><00:16:15.040><c> is</c><00:16:15.600><c> non-</c><00:16:15.839><c> returning</c>

00:16:16.230 --> 00:16:16.240 align:start position:0%
wanted to mention is non- returning
 

00:16:16.240 --> 00:16:18.790 align:start position:0%
wanted to mention is non- returning
functions<00:16:16.600><c> and</c><00:16:16.800><c> jump</c><00:16:17.120><c> F</c><00:16:17.920><c> these</c><00:16:18.079><c> are</c><00:16:18.360><c> defined</c>

00:16:18.790 --> 00:16:18.800 align:start position:0%
functions and jump F these are defined
 

00:16:18.800 --> 00:16:22.069 align:start position:0%
functions and jump F these are defined
in<00:16:18.959><c> their</c><00:16:19.199><c> own</c><00:16:19.480><c> EIP</c><00:16:20.319><c> but</c><00:16:20.959><c> they</c><00:16:21.120><c> are</c><00:16:21.720><c> closely</c>

00:16:22.069 --> 00:16:22.079 align:start position:0%
in their own EIP but they are closely
 

00:16:22.079 --> 00:16:23.829 align:start position:0%
in their own EIP but they are closely
related<00:16:22.360><c> to</c><00:16:22.480><c> stack</c><00:16:22.720><c> validation</c><00:16:23.360><c> and</c>

00:16:23.829 --> 00:16:23.839 align:start position:0%
related to stack validation and
 

00:16:23.839 --> 00:16:25.710 align:start position:0%
related to stack validation and
partially<00:16:24.279><c> motivated</c><00:16:24.800><c> by</c><00:16:24.920><c> Stack</c><00:16:25.199><c> validation</c>

00:16:25.710 --> 00:16:25.720 align:start position:0%
partially motivated by Stack validation
 

00:16:25.720 --> 00:16:28.710 align:start position:0%
partially motivated by Stack validation
I<00:16:25.800><c> would</c><00:16:26.079><c> say</c><00:16:27.079><c> so</c><00:16:27.319><c> non</c><00:16:27.959><c> functions</c><00:16:28.279><c> are</c><00:16:28.519><c> those</c>

00:16:28.710 --> 00:16:28.720 align:start position:0%
I would say so non functions are those
 

00:16:28.720 --> 00:16:31.350 align:start position:0%
I would say so non functions are those
that<00:16:29.000><c> do</c><00:16:29.160><c> not</c><00:16:29.519><c> return</c><00:16:29.920><c> control</c><00:16:30.440><c> back</c><00:16:30.759><c> to</c><00:16:31.120><c> a</c>

00:16:31.350 --> 00:16:31.360 align:start position:0%
that do not return control back to a
 

00:16:31.360 --> 00:16:33.910 align:start position:0%
that do not return control back to a
caller<00:16:31.839><c> they</c><00:16:32.000><c> do</c><00:16:32.120><c> not</c><00:16:32.319><c> execute</c><00:16:32.720><c> red</c><00:16:33.040><c> f</c>

00:16:33.910 --> 00:16:33.920 align:start position:0%
caller they do not execute red f
 

00:16:33.920 --> 00:16:35.910 align:start position:0%
caller they do not execute red f
instruction<00:16:34.920><c> or</c><00:16:35.120><c> you</c><00:16:35.199><c> could</c><00:16:35.360><c> think</c><00:16:35.519><c> of</c><00:16:35.680><c> them</c>

00:16:35.910 --> 00:16:35.920 align:start position:0%
instruction or you could think of them
 

00:16:35.920 --> 00:16:39.069 align:start position:0%
instruction or you could think of them
as<00:16:36.880><c> functions</c><00:16:37.319><c> that</c><00:16:37.680><c> and</c><00:16:38.160><c> entire</c><00:16:38.639><c> contract</c>

00:16:39.069 --> 00:16:39.079 align:start position:0%
as functions that and entire contract
 

00:16:39.079 --> 00:16:40.870 align:start position:0%
as functions that and entire contract
execution<00:16:39.720><c> with</c><00:16:39.880><c> instructions</c><00:16:40.360><c> like</c><00:16:40.480><c> stop</c>

00:16:40.870 --> 00:16:40.880 align:start position:0%
execution with instructions like stop
 

00:16:40.880 --> 00:16:42.710 align:start position:0%
execution with instructions like stop
return<00:16:41.160><c> revert</c>

00:16:42.710 --> 00:16:42.720 align:start position:0%
return revert
 

00:16:42.720 --> 00:16:45.509 align:start position:0%
return revert
Etc<00:16:43.720><c> uh</c><00:16:43.880><c> how</c><00:16:44.079><c> is</c><00:16:44.279><c> this</c><00:16:44.519><c> relevant</c><00:16:44.959><c> to</c><00:16:45.120><c> stack</c>

00:16:45.509 --> 00:16:45.519 align:start position:0%
Etc uh how is this relevant to stack
 

00:16:45.519 --> 00:16:48.910 align:start position:0%
Etc uh how is this relevant to stack
validation<00:16:46.519><c> um</c><00:16:47.160><c> so</c><00:16:47.519><c> when</c><00:16:47.720><c> we</c><00:16:47.959><c> validate</c><00:16:48.440><c> a</c><00:16:48.639><c> call</c>

00:16:48.910 --> 00:16:48.920 align:start position:0%
validation um so when we validate a call
 

00:16:48.920 --> 00:16:50.829 align:start position:0%
validation um so when we validate a call
to<00:16:49.120><c> such</c><00:16:49.279><c> a</c><00:16:49.440><c> non-returning</c>

00:16:50.829 --> 00:16:50.839 align:start position:0%
to such a non-returning
 

00:16:50.839 --> 00:16:52.870 align:start position:0%
to such a non-returning
function<00:16:51.839><c> if</c><00:16:52.040><c> there's</c><00:16:52.279><c> some</c><00:16:52.519><c> code</c>

00:16:52.870 --> 00:16:52.880 align:start position:0%
function if there's some code
 

00:16:52.880 --> 00:16:55.509 align:start position:0%
function if there's some code
immediately<00:16:53.319><c> following</c><00:16:53.800><c> this</c><00:16:54.199><c> call</c><00:16:55.160><c> uh</c><00:16:55.319><c> this</c>

00:16:55.509 --> 00:16:55.519 align:start position:0%
immediately following this call uh this
 

00:16:55.519 --> 00:16:57.189 align:start position:0%
immediately following this call uh this
code<00:16:55.839><c> is</c><00:16:56.000><c> never</c><00:16:56.240><c> going</c><00:16:56.399><c> to</c><00:16:56.519><c> be</c><00:16:56.680><c> executed</c><00:16:57.079><c> at</c>

00:16:57.189 --> 00:16:57.199 align:start position:0%
code is never going to be executed at
 

00:16:57.199 --> 00:16:59.550 align:start position:0%
code is never going to be executed at
run<00:16:57.440><c> time</c><00:16:57.639><c> because</c><00:16:57.880><c> this</c><00:16:58.040><c> call</c><00:16:58.319><c> is</c><00:16:58.639><c> not</c>

00:16:59.550 --> 00:16:59.560 align:start position:0%
run time because this call is not
 

00:16:59.560 --> 00:17:02.430 align:start position:0%
run time because this call is not
returning<00:17:00.560><c> this</c><00:17:00.759><c> means</c><00:17:01.240><c> that</c><00:17:01.639><c> we</c><00:17:01.800><c> do</c><00:17:01.959><c> not</c><00:17:02.160><c> need</c>

00:17:02.430 --> 00:17:02.440 align:start position:0%
returning this means that we do not need
 

00:17:02.440 --> 00:17:04.350 align:start position:0%
returning this means that we do not need
and<00:17:02.600><c> we</c><00:17:02.720><c> should</c><00:17:02.959><c> not</c><00:17:03.240><c> validate</c><00:17:03.720><c> this</c><00:17:03.959><c> code</c>

00:17:04.350 --> 00:17:04.360 align:start position:0%
and we should not validate this code
 

00:17:04.360 --> 00:17:05.909 align:start position:0%
and we should not validate this code
following<00:17:04.760><c> the</c><00:17:04.839><c> call</c><00:17:05.039><c> to</c><00:17:05.160><c> non</c>

00:17:05.909 --> 00:17:05.919 align:start position:0%
following the call to non
 

00:17:05.919 --> 00:17:08.750 align:start position:0%
following the call to non
returning<00:17:06.919><c> instead</c><00:17:07.280><c> we</c><00:17:07.439><c> should</c><00:17:08.160><c> uh</c><00:17:08.439><c> consider</c>

00:17:08.750 --> 00:17:08.760 align:start position:0%
returning instead we should uh consider
 

00:17:08.760 --> 00:17:10.669 align:start position:0%
returning instead we should uh consider
it<00:17:08.880><c> unreachable</c><00:17:09.400><c> and</c><00:17:09.600><c> reject</c><00:17:09.919><c> it</c><00:17:10.280><c> as</c><00:17:10.400><c> we</c><00:17:10.520><c> do</c>

00:17:10.669 --> 00:17:10.679 align:start position:0%
it unreachable and reject it as we do
 

00:17:10.679 --> 00:17:12.750 align:start position:0%
it unreachable and reject it as we do
with<00:17:10.839><c> other</c><00:17:11.039><c> unreachable</c><00:17:11.559><c> code</c><00:17:12.280><c> uh</c><00:17:12.400><c> so</c><00:17:12.559><c> to</c>

00:17:12.750 --> 00:17:12.760 align:start position:0%
with other unreachable code uh so to
 

00:17:12.760 --> 00:17:14.429 align:start position:0%
with other unreachable code uh so to
make<00:17:13.000><c> this</c><00:17:13.160><c> work</c><00:17:13.439><c> stack</c><00:17:13.679><c> validation</c><00:17:14.120><c> has</c><00:17:14.240><c> to</c>

00:17:14.429 --> 00:17:14.439 align:start position:0%
make this work stack validation has to
 

00:17:14.439 --> 00:17:16.230 align:start position:0%
make this work stack validation has to
detect<00:17:14.880><c> calls</c><00:17:15.120><c> to</c><00:17:15.240><c> non-</c><00:17:15.439><c> returning</c><00:17:15.799><c> functions</c>

00:17:16.230 --> 00:17:16.240 align:start position:0%
detect calls to non- returning functions
 

00:17:16.240 --> 00:17:18.789 align:start position:0%
detect calls to non- returning functions
somehow<00:17:17.240><c> for</c><00:17:17.480><c> that</c><00:17:17.600><c> we</c><00:17:17.760><c> have</c><00:17:17.880><c> a</c><00:17:18.039><c> special</c><00:17:18.360><c> flag</c>

00:17:18.789 --> 00:17:18.799 align:start position:0%
somehow for that we have a special flag
 

00:17:18.799 --> 00:17:21.270 align:start position:0%
somehow for that we have a special flag
in<00:17:19.000><c> the</c><00:17:19.160><c> EF</c><00:17:19.600><c> header</c><00:17:20.039><c> in</c><00:17:20.439><c> the</c><00:17:20.720><c> functions</c>

00:17:21.270 --> 00:17:21.280 align:start position:0%
in the EF header in the functions
 

00:17:21.280 --> 00:17:24.069 align:start position:0%
in the EF header in the functions
metadata<00:17:22.280><c> so</c><00:17:22.480><c> when</c><00:17:22.679><c> stack</c><00:17:22.959><c> validation</c><00:17:23.880><c> uh</c>

00:17:24.069 --> 00:17:24.079 align:start position:0%
metadata so when stack validation uh
 

00:17:24.079 --> 00:17:26.990 align:start position:0%
metadata so when stack validation uh
detects<00:17:24.839><c> a</c><00:17:25.199><c> call</c><00:17:26.079><c> when</c><00:17:26.240><c> it</c><00:17:26.360><c> sees</c><00:17:26.559><c> a</c><00:17:26.679><c> call</c><00:17:26.919><c> it</c>

00:17:26.990 --> 00:17:27.000 align:start position:0%
detects a call when it sees a call it
 

00:17:27.000 --> 00:17:28.350 align:start position:0%
detects a call when it sees a call it
checks<00:17:27.280><c> this</c><00:17:27.439><c> flag</c><00:17:27.760><c> whether</c><00:17:27.919><c> it's</c><00:17:28.039><c> returning</c>

00:17:28.350 --> 00:17:28.360 align:start position:0%
checks this flag whether it's returning
 

00:17:28.360 --> 00:17:30.029 align:start position:0%
checks this flag whether it's returning
or<00:17:28.439><c> non</c><00:17:28.559><c> rur</c><00:17:29.120><c> if</c><00:17:29.200><c> it's</c><00:17:29.320><c> a</c><00:17:29.440><c> call</c><00:17:29.640><c> to</c><00:17:29.799><c> non-</c>

00:17:30.029 --> 00:17:30.039 align:start position:0%
or non rur if it's a call to non-
 

00:17:30.039 --> 00:17:31.990 align:start position:0%
or non rur if it's a call to non-
returning<00:17:30.720><c> function</c><00:17:31.200><c> it</c><00:17:31.360><c> considers</c><00:17:31.840><c> this</c>

00:17:31.990 --> 00:17:32.000 align:start position:0%
returning function it considers this
 

00:17:32.000 --> 00:17:34.510 align:start position:0%
returning function it considers this
call<00:17:32.240><c> to</c><00:17:32.320><c> be</c><00:17:32.440><c> a</c><00:17:32.559><c> terminated</c><00:17:33.120><c> instruction</c><00:17:33.760><c> and</c>

00:17:34.510 --> 00:17:34.520 align:start position:0%
call to be a terminated instruction and
 

00:17:34.520 --> 00:17:37.029 align:start position:0%
call to be a terminated instruction and
then<00:17:35.520><c> uh</c><00:17:35.760><c> in</c><00:17:35.880><c> the</c><00:17:36.000><c> end</c><00:17:36.240><c> then</c><00:17:36.400><c> if</c><00:17:36.559><c> there's</c><00:17:36.880><c> some</c>

00:17:37.029 --> 00:17:37.039 align:start position:0%
then uh in the end then if there's some
 

00:17:37.039 --> 00:17:39.350 align:start position:0%
then uh in the end then if there's some
code<00:17:37.240><c> immediately</c><00:17:37.640><c> following</c><00:17:38.039><c> it</c><00:17:38.440><c> it</c><00:17:38.840><c> it</c><00:17:39.160><c> may</c>

00:17:39.350 --> 00:17:39.360 align:start position:0%
code immediately following it it it may
 

00:17:39.360 --> 00:17:41.270 align:start position:0%
code immediately following it it it may
be<00:17:39.480><c> unreachable</c><00:17:40.039><c> unless</c><00:17:40.360><c> there</c><00:17:40.520><c> was</c><00:17:40.760><c> some</c>

00:17:41.270 --> 00:17:41.280 align:start position:0%
be unreachable unless there was some
 

00:17:41.280 --> 00:17:43.430 align:start position:0%
be unreachable unless there was some
previously<00:17:41.679><c> seen</c><00:17:41.960><c> forward</c><00:17:42.320><c> jump</c><00:17:42.600><c> into</c><00:17:42.799><c> it</c><00:17:43.280><c> so</c>

00:17:43.430 --> 00:17:43.440 align:start position:0%
previously seen forward jump into it so
 

00:17:43.440 --> 00:17:44.750 align:start position:0%
previously seen forward jump into it so
this<00:17:43.559><c> is</c><00:17:43.679><c> how</c><00:17:43.799><c> it</c><00:17:43.919><c> works</c><00:17:44.200><c> what's</c><00:17:44.400><c> important</c>

00:17:44.750 --> 00:17:44.760 align:start position:0%
this is how it works what's important
 

00:17:44.760 --> 00:17:46.870 align:start position:0%
this is how it works what's important
here<00:17:44.960><c> is</c><00:17:45.120><c> that</c><00:17:45.320><c> calls</c><00:17:45.600><c> to</c><00:17:45.799><c> returning</c><00:17:46.440><c> and</c><00:17:46.600><c> non-</c>

00:17:46.870 --> 00:17:46.880 align:start position:0%
here is that calls to returning and non-
 

00:17:46.880 --> 00:17:48.909 align:start position:0%
here is that calls to returning and non-
returning<00:17:47.280><c> functions</c><00:17:47.679><c> are</c><00:17:47.880><c> validated</c><00:17:48.480><c> very</c>

00:17:48.909 --> 00:17:48.919 align:start position:0%
returning functions are validated very
 

00:17:48.919 --> 00:17:51.110 align:start position:0%
returning functions are validated very
differently<00:17:49.919><c> so</c><00:17:50.120><c> for</c><00:17:50.320><c> calls</c><00:17:50.559><c> to</c><00:17:50.720><c> returning</c>

00:17:51.110 --> 00:17:51.120 align:start position:0%
differently so for calls to returning
 

00:17:51.120 --> 00:17:52.510 align:start position:0%
differently so for calls to returning
functions<00:17:51.440><c> you</c><00:17:51.559><c> have</c><00:17:51.679><c> to</c><00:17:51.799><c> take</c><00:17:51.960><c> into</c><00:17:52.200><c> account</c>

00:17:52.510 --> 00:17:52.520 align:start position:0%
functions you have to take into account
 

00:17:52.520 --> 00:17:54.630 align:start position:0%
functions you have to take into account
how<00:17:52.640><c> many</c><00:17:53.320><c> values</c><00:17:53.640><c> were</c><00:17:54.000><c> returned</c><00:17:54.360><c> put</c><00:17:54.520><c> them</c>

00:17:54.630 --> 00:17:54.640 align:start position:0%
how many values were returned put them
 

00:17:54.640 --> 00:17:56.350 align:start position:0%
how many values were returned put them
on<00:17:54.840><c> stack</c><00:17:55.120><c> and</c><00:17:55.280><c> continue</c><00:17:55.640><c> validation</c><00:17:56.200><c> and</c>

00:17:56.350 --> 00:17:56.360 align:start position:0%
on stack and continue validation and
 

00:17:56.360 --> 00:17:57.750 align:start position:0%
on stack and continue validation and
calls<00:17:56.679><c> to</c><00:17:56.799><c> non-</c><00:17:57.039><c> returning</c><00:17:57.400><c> ad</c><00:17:57.600><c> just</c>

00:17:57.750 --> 00:17:57.760 align:start position:0%
calls to non- returning ad just
 

00:17:57.760 --> 00:17:59.470 align:start position:0%
calls to non- returning ad just
terminating<00:17:58.200><c> instructions</c>

00:17:59.470 --> 00:17:59.480 align:start position:0%
terminating instructions
 

00:17:59.480 --> 00:18:02.669 align:start position:0%
terminating instructions
given<00:17:59.760><c> this</c><00:18:00.039><c> difference</c><00:18:00.520><c> I</c><00:18:00.600><c> would</c><00:18:01.120><c> say</c><00:18:02.120><c> uh</c><00:18:02.440><c> a</c>

00:18:02.669 --> 00:18:02.679 align:start position:0%
given this difference I would say uh a
 

00:18:02.679 --> 00:18:04.990 align:start position:0%
given this difference I would say uh a
separate<00:18:03.240><c> instruction</c><00:18:03.760><c> for</c><00:18:04.000><c> C</c><00:18:04.559><c> return</c><00:18:04.840><c> is</c>

00:18:04.990 --> 00:18:05.000 align:start position:0%
separate instruction for C return is
 

00:18:05.000 --> 00:18:07.470 align:start position:0%
separate instruction for C return is
already<00:18:05.400><c> Justified</c><00:18:06.039><c> so</c><00:18:06.559><c> this</c><00:18:06.880><c> is</c><00:18:07.080><c> exactly</c>

00:18:07.470 --> 00:18:07.480 align:start position:0%
already Justified so this is exactly
 

00:18:07.480 --> 00:18:09.789 align:start position:0%
already Justified so this is exactly
what<00:18:07.679><c> jump</c><00:18:08.000><c> F</c><00:18:08.200><c> instruction</c><00:18:08.799><c> is</c><00:18:09.440><c> if</c><00:18:09.520><c> you</c><00:18:09.640><c> need</c>

00:18:09.789 --> 00:18:09.799 align:start position:0%
what jump F instruction is if you need
 

00:18:09.799 --> 00:18:13.470 align:start position:0%
what jump F instruction is if you need
to<00:18:09.919><c> do</c><00:18:10.080><c> a</c><00:18:10.200><c> call</c><00:18:10.360><c> to</c><00:18:10.520><c> non</c><00:18:11.120><c> function</c><00:18:11.960><c> you</c><00:18:12.960><c> uh</c><00:18:13.200><c> use</c>

00:18:13.470 --> 00:18:13.480 align:start position:0%
to do a call to non function you uh use
 

00:18:13.480 --> 00:18:15.789 align:start position:0%
to do a call to non function you uh use
jump<00:18:13.760><c> f</c><00:18:13.919><c> for</c><00:18:14.080><c> that</c><00:18:14.240><c> call</c><00:18:14.480><c> F</c><00:18:14.640><c> to</c><00:18:14.799><c> non</c><00:18:14.960><c> returning</c>

00:18:15.789 --> 00:18:15.799 align:start position:0%
jump f for that call F to non returning
 

00:18:15.799 --> 00:18:18.950 align:start position:0%
jump f for that call F to non returning
is<00:18:15.960><c> not</c><00:18:16.200><c> allowed</c><00:18:16.960><c> in</c>

00:18:18.950 --> 00:18:18.960 align:start position:0%
is not allowed in
 

00:18:18.960 --> 00:18:22.470 align:start position:0%
is not allowed in
fact<00:18:19.960><c> uh</c><00:18:20.120><c> jump</c><00:18:20.440><c> F</c><00:18:20.720><c> also</c><00:18:21.039><c> has</c><00:18:21.799><c> different</c><00:18:22.159><c> use</c>

00:18:22.470 --> 00:18:22.480 align:start position:0%
fact uh jump F also has different use
 

00:18:22.480 --> 00:18:24.230 align:start position:0%
fact uh jump F also has different use
case<00:18:22.640><c> it</c><00:18:22.799><c> can</c><00:18:22.919><c> be</c><00:18:23.039><c> used</c><00:18:23.440><c> with</c><00:18:23.679><c> returning</c>

00:18:24.230 --> 00:18:24.240 align:start position:0%
case it can be used with returning
 

00:18:24.240 --> 00:18:27.070 align:start position:0%
case it can be used with returning
functions<00:18:24.919><c> but</c><00:18:25.440><c> uh</c><00:18:25.640><c> this</c><00:18:25.919><c> does</c><00:18:26.120><c> not</c><00:18:26.320><c> fit</c><00:18:26.720><c> this</c>

00:18:27.070 --> 00:18:27.080 align:start position:0%
functions but uh this does not fit this
 

00:18:27.080 --> 00:18:29.110 align:start position:0%
functions but uh this does not fit this
presentation<00:18:28.080><c> but</c><00:18:28.240><c> you</c><00:18:28.360><c> can</c><00:18:28.840><c> read</c><00:18:28.960><c> more</c>

00:18:29.110 --> 00:18:29.120 align:start position:0%
presentation but you can read more
 

00:18:29.120 --> 00:18:32.270 align:start position:0%
presentation but you can read more
details<00:18:29.520><c> in</c><00:18:29.640><c> the</c><00:18:29.760><c> EIP</c><00:18:30.440><c> or</c><00:18:31.440><c> some</c><00:18:31.679><c> discussion</c><00:18:32.080><c> at</c>

00:18:32.270 --> 00:18:32.280 align:start position:0%
details in the EIP or some discussion at
 

00:18:32.280 --> 00:18:34.029 align:start position:0%
details in the EIP or some discussion at
this<00:18:32.720><c> another</c>

00:18:34.029 --> 00:18:34.039 align:start position:0%
this another
 

00:18:34.039 --> 00:18:36.750 align:start position:0%
this another
link<00:18:35.039><c> and</c><00:18:35.240><c> this</c><00:18:35.360><c> is</c><00:18:35.640><c> what</c><00:18:35.840><c> all</c><00:18:36.120><c> that</c><00:18:36.240><c> I</c><00:18:36.360><c> wanted</c>

00:18:36.750 --> 00:18:36.760 align:start position:0%
link and this is what all that I wanted
 

00:18:36.760 --> 00:18:44.270 align:start position:0%
link and this is what all that I wanted
to<00:18:36.919><c> say</c><00:18:37.159><c> about</c><00:18:37.440><c> this</c><00:18:37.720><c> thank</c>

00:18:44.270 --> 00:18:44.280 align:start position:0%
 
 

00:18:44.280 --> 00:18:46.950 align:start position:0%
 
you<00:18:45.280><c> thanks</c><00:18:45.480><c> a</c><00:18:45.679><c> lot</c><00:18:46.080><c> that</c><00:18:46.240><c> was</c><00:18:46.440><c> a</c><00:18:46.760><c> very</c>

00:18:46.950 --> 00:18:46.960 align:start position:0%
you thanks a lot that was a very
 

00:18:46.960 --> 00:18:50.190 align:start position:0%
you thanks a lot that was a very
interesting<00:18:47.440><c> presentation</c><00:18:48.400><c> so</c><00:18:49.240><c> let's</c><00:18:49.520><c> start</c>

00:18:50.190 --> 00:18:50.200 align:start position:0%
interesting presentation so let's start
 

00:18:50.200 --> 00:18:53.149 align:start position:0%
interesting presentation so let's start
uh<00:18:50.600><c> with</c><00:18:51.120><c> uh</c><00:18:51.320><c> the</c><00:18:51.600><c> questions</c><00:18:52.600><c> uh</c><00:18:52.760><c> the</c><00:18:52.919><c> most</c>

00:18:53.149 --> 00:18:53.159 align:start position:0%
uh with uh the questions uh the most
 

00:18:53.159 --> 00:18:57.549 align:start position:0%
uh with uh the questions uh the most
popular<00:18:53.559><c> one</c><00:18:54.120><c> is</c><00:18:55.159><c> um</c><00:18:56.159><c> uh</c><00:18:56.760><c> good</c><00:18:57.280><c> stack</c>

00:18:57.549 --> 00:18:57.559 align:start position:0%
popular one is um uh good stack
 

00:18:57.559 --> 00:18:59.909 align:start position:0%
popular one is um uh good stack
validation<00:18:58.240><c> allowed</c><00:18:58.840><c> translation</c><00:18:59.559><c> to</c><00:18:59.760><c> a</c>

00:18:59.909 --> 00:18:59.919 align:start position:0%
validation allowed translation to a
 

00:18:59.919 --> 00:19:01.470 align:start position:0%
validation allowed translation to a
register<00:19:00.400><c> based</c><00:19:00.760><c> instruction</c><00:19:01.200><c> set</c>

00:19:01.470 --> 00:19:01.480 align:start position:0%
register based instruction set
 

00:19:01.480 --> 00:19:05.510 align:start position:0%
register based instruction set
internally<00:19:02.640><c> reducing</c><00:19:03.760><c> dispatch</c><00:19:04.760><c> overhead</c><00:19:05.360><c> in</c>

00:19:05.510 --> 00:19:05.520 align:start position:0%
internally reducing dispatch overhead in
 

00:19:05.520 --> 00:19:07.190 align:start position:0%
internally reducing dispatch overhead in
The<00:19:05.640><c> Interpreter</c>

00:19:07.190 --> 00:19:07.200 align:start position:0%
The Interpreter
 

00:19:07.200 --> 00:19:12.510 align:start position:0%
The Interpreter
loop<00:19:08.200><c> I</c><00:19:08.320><c> think</c><00:19:08.559><c> definitely</c><00:19:09.039><c> it</c>

00:19:12.510 --> 00:19:12.520 align:start position:0%
 
 

00:19:12.520 --> 00:19:16.789 align:start position:0%
 
can<00:19:13.520><c> any</c><00:19:13.799><c> any</c><00:19:14.039><c> translation</c><00:19:14.559><c> is</c><00:19:15.240><c> easier</c><00:19:16.159><c> uh</c><00:19:16.600><c> in</c>

00:19:16.789 --> 00:19:16.799 align:start position:0%
can any any translation is easier uh in
 

00:19:16.799 --> 00:19:19.750 align:start position:0%
can any any translation is easier uh in
eof<00:19:17.559><c> given</c><00:19:17.840><c> that</c><00:19:18.000><c> we</c><00:19:18.159><c> have</c><00:19:18.640><c> we</c><00:19:18.760><c> do</c><00:19:18.880><c> not</c><00:19:19.080><c> have</c>

00:19:19.750 --> 00:19:19.760 align:start position:0%
eof given that we have we do not have
 

00:19:19.760 --> 00:19:21.230 align:start position:0%
eof given that we have we do not have
Dynamic<00:19:20.080><c> jumps</c><00:19:20.440><c> that's</c><00:19:20.559><c> the</c><00:19:20.679><c> main</c><00:19:20.880><c> reason</c>

00:19:21.230 --> 00:19:21.240 align:start position:0%
Dynamic jumps that's the main reason
 

00:19:21.240 --> 00:19:24.230 align:start position:0%
Dynamic jumps that's the main reason
that<00:19:21.760><c> we</c><00:19:21.880><c> can</c><00:19:22.080><c> do</c><00:19:22.320><c> jittin</c><00:19:22.880><c> we</c><00:19:23.000><c> can</c><00:19:23.400><c> compile</c><00:19:23.799><c> to</c>

00:19:24.230 --> 00:19:24.240 align:start position:0%
that we can do jittin we can compile to
 

00:19:24.240 --> 00:19:28.390 align:start position:0%
that we can do jittin we can compile to
whatever<00:19:25.280><c> backand</c><00:19:26.280><c> uh</c><00:19:26.440><c> it's</c><00:19:26.799><c> yeah</c><00:19:27.600><c> there</c><00:19:27.720><c> are</c>

00:19:28.390 --> 00:19:28.400 align:start position:0%
whatever backand uh it's yeah there are
 

00:19:28.400 --> 00:19:30.990 align:start position:0%
whatever backand uh it's yeah there are
various<00:19:28.840><c> ideas</c><00:19:29.200><c> about</c><00:19:30.080><c> what</c><00:19:30.280><c> EF</c><00:19:30.720><c> can</c><00:19:30.840><c> be</c>

00:19:30.990 --> 00:19:31.000 align:start position:0%
various ideas about what EF can be
 

00:19:31.000 --> 00:19:36.549 align:start position:0%
various ideas about what EF can be
compiled<00:19:31.440><c> to</c><00:19:32.360><c> uh</c><00:19:32.880><c> uh</c><00:19:33.400><c> not</c>

00:19:36.549 --> 00:19:36.559 align:start position:0%
 
 

00:19:36.559 --> 00:19:40.350 align:start position:0%
 
yeah<00:19:37.559><c> interesting</c><00:19:37.960><c> topic</c><00:19:38.720><c> yeah</c><00:19:39.720><c> okay</c><00:19:40.200><c> the</c>

00:19:40.350 --> 00:19:40.360 align:start position:0%
yeah interesting topic yeah okay the
 

00:19:40.360 --> 00:19:43.350 align:start position:0%
yeah interesting topic yeah okay the
next<00:19:40.640><c> question</c><00:19:41.000><c> is</c><00:19:41.559><c> since</c><00:19:42.000><c> stack</c><00:19:42.360><c> size</c><00:19:42.679><c> can</c>

00:19:43.350 --> 00:19:43.360 align:start position:0%
next question is since stack size can
 

00:19:43.360 --> 00:19:46.350 align:start position:0%
next question is since stack size can
vary<00:19:43.679><c> with</c><00:19:43.880><c> recursion</c><00:19:44.679><c> which</c><00:19:44.880><c> is</c><00:19:45.159><c> only</c><00:19:45.440><c> known</c>

00:19:46.350 --> 00:19:46.360 align:start position:0%
vary with recursion which is only known
 

00:19:46.360 --> 00:19:48.549 align:start position:0%
vary with recursion which is only known
uh<00:19:46.480><c> at</c><00:19:46.679><c> run</c><00:19:46.960><c> time</c><00:19:47.480><c> how</c><00:19:47.679><c> can</c><00:19:47.960><c> this</c><00:19:48.200><c> method</c>

00:19:48.549 --> 00:19:48.559 align:start position:0%
uh at run time how can this method
 

00:19:48.559 --> 00:19:52.350 align:start position:0%
uh at run time how can this method
ensure<00:19:49.320><c> St</c><00:19:49.799><c> stack</c><00:19:50.280><c> Overflow</c><00:19:51.120><c> is</c><00:19:51.280><c> detected</c>

00:19:52.350 --> 00:19:52.360 align:start position:0%
ensure St stack Overflow is detected
 

00:19:52.360 --> 00:19:55.310 align:start position:0%
ensure St stack Overflow is detected
statically<00:19:53.360><c> good</c><00:19:53.600><c> question</c><00:19:54.120><c> so</c><00:19:54.600><c> it</c><00:19:54.760><c> is</c><00:19:55.120><c> we</c>

00:19:55.310 --> 00:19:55.320 align:start position:0%
statically good question so it is we
 

00:19:55.320 --> 00:19:59.510 align:start position:0%
statically good question so it is we
still<00:19:56.000><c> uh</c><00:19:56.679><c> uh</c><00:19:57.159><c> require</c><00:19:58.120><c> runtime</c><00:19:58.880><c> for</c><00:19:59.000><c> overflow</c>

00:19:59.510 --> 00:19:59.520 align:start position:0%
still uh uh require runtime for overflow
 

00:19:59.520 --> 00:20:01.669 align:start position:0%
still uh uh require runtime for overflow
we<00:19:59.720><c> just</c><00:20:00.000><c> don't</c><00:20:00.240><c> do</c><00:20:00.480><c> them</c><00:20:01.080><c> every</c><00:20:01.320><c> time</c><00:20:01.520><c> at</c>

00:20:01.669 --> 00:20:01.679 align:start position:0%
we just don't do them every time at
 

00:20:01.679 --> 00:20:03.950 align:start position:0%
we just don't do them every time at
every

00:20:03.950 --> 00:20:03.960 align:start position:0%
 
 

00:20:03.960 --> 00:20:07.149 align:start position:0%
 
instruction<00:20:04.960><c> so</c><00:20:05.559><c> uh</c><00:20:06.200><c> the</c><00:20:06.360><c> recursive</c><00:20:06.840><c> calls</c>

00:20:07.149 --> 00:20:07.159 align:start position:0%
instruction so uh the recursive calls
 

00:20:07.159 --> 00:20:09.470 align:start position:0%
instruction so uh the recursive calls
will<00:20:07.360><c> still</c><00:20:08.080><c> do</c><00:20:08.320><c> the</c><00:20:08.480><c> Overflow</c><00:20:08.960><c> check</c><00:20:09.280><c> when</c>

00:20:09.470 --> 00:20:09.480 align:start position:0%
will still do the Overflow check when
 

00:20:09.480 --> 00:20:11.430 align:start position:0%
will still do the Overflow check when
they<00:20:09.600><c> do</c><00:20:09.840><c> a</c><00:20:10.000><c> call</c><00:20:10.559><c> callif</c><00:20:10.919><c> or</c><00:20:11.039><c> jump</c><00:20:11.240><c> off</c>

00:20:11.430 --> 00:20:11.440 align:start position:0%
they do a call callif or jump off
 

00:20:11.440 --> 00:20:14.549 align:start position:0%
they do a call callif or jump off
instruction<00:20:12.000><c> and</c><00:20:12.280><c> in</c><00:20:12.480><c> case</c><00:20:13.080><c> uh</c><00:20:13.320><c> this</c><00:20:13.840><c> call</c><00:20:14.240><c> May</c>

00:20:14.549 --> 00:20:14.559 align:start position:0%
instruction and in case uh this call May
 

00:20:14.559 --> 00:20:16.669 align:start position:0%
instruction and in case uh this call May
overflow<00:20:15.240><c> this</c><00:20:15.559><c> call</c><00:20:15.799><c> is</c><00:20:15.919><c> not</c><00:20:16.080><c> going</c><00:20:16.240><c> to</c><00:20:16.400><c> be</c>

00:20:16.669 --> 00:20:16.679 align:start position:0%
overflow this call is not going to be
 

00:20:16.679 --> 00:20:18.669 align:start position:0%
overflow this call is not going to be
succeeded<00:20:17.200><c> so</c><00:20:17.600><c> overflow</c><00:20:18.039><c> checks</c><00:20:18.240><c> are</c><00:20:18.400><c> not</c>

00:20:18.669 --> 00:20:18.679 align:start position:0%
succeeded so overflow checks are not
 

00:20:18.679 --> 00:20:20.630 align:start position:0%
succeeded so overflow checks are not
checked<00:20:19.039><c> completely</c><00:20:19.679><c> statically</c><00:20:20.400><c> that's</c>

00:20:20.630 --> 00:20:20.640 align:start position:0%
checked completely statically that's
 

00:20:20.640 --> 00:20:22.390 align:start position:0%
checked completely statically that's
that's<00:20:20.799><c> the</c>

00:20:22.390 --> 00:20:22.400 align:start position:0%
that's the
 

00:20:22.400 --> 00:20:26.909 align:start position:0%
that's the
answer<00:20:23.640><c> great</c><00:20:24.640><c> uh</c><00:20:25.240><c> so</c><00:20:25.760><c> the</c><00:20:26.000><c> next</c><00:20:26.320><c> question</c><00:20:26.760><c> I</c>

00:20:26.909 --> 00:20:26.919 align:start position:0%
answer great uh so the next question I
 

00:20:26.919 --> 00:20:29.510 align:start position:0%
answer great uh so the next question I
think<00:20:27.440><c> uh</c><00:20:27.720><c> in</c><00:20:27.840><c> the</c><00:20:28.039><c> beginning</c><00:20:28.760><c> you</c><00:20:28.960><c> mentioned</c>

00:20:29.510 --> 00:20:29.520 align:start position:0%
think uh in the beginning you mentioned
 

00:20:29.520 --> 00:20:32.149 align:start position:0%
think uh in the beginning you mentioned
that<00:20:29.880><c> uh</c><00:20:30.080><c> some</c><00:20:30.440><c> compiler</c><00:20:31.159><c> optimizations</c>

00:20:32.149 --> 00:20:32.159 align:start position:0%
that uh some compiler optimizations
 

00:20:32.159 --> 00:20:34.789 align:start position:0%
that uh some compiler optimizations
won't<00:20:32.480><c> be</c><00:20:32.720><c> worth</c><00:20:32.960><c> it</c><00:20:33.559><c> so</c><00:20:33.799><c> I</c><00:20:34.000><c> guess</c><00:20:34.400><c> uh</c><00:20:34.559><c> which</c>

00:20:34.789 --> 00:20:34.799 align:start position:0%
won't be worth it so I guess uh which
 

00:20:34.799 --> 00:20:36.830 align:start position:0%
won't be worth it so I guess uh which
compilers<00:20:35.280><c> optimizations</c><00:20:36.120><c> won't</c><00:20:36.320><c> be</c><00:20:36.440><c> worth</c>

00:20:36.830 --> 00:20:36.840 align:start position:0%
compilers optimizations won't be worth
 

00:20:36.840 --> 00:20:39.390 align:start position:0%
compilers optimizations won't be worth
yeah<00:20:37.240><c> so</c><00:20:37.760><c> I</c><00:20:37.880><c> refer</c><00:20:38.280><c> to</c><00:20:38.559><c> this</c><00:20:38.760><c> one</c><00:20:39.000><c> specific</c>

00:20:39.390 --> 00:20:39.400 align:start position:0%
yeah so I refer to this one specific
 

00:20:39.400 --> 00:20:43.230 align:start position:0%
yeah so I refer to this one specific
case<00:20:39.720><c> that</c><00:20:40.320><c> uh</c><00:20:40.559><c> was</c><00:20:41.039><c> pretty</c><00:20:41.360><c> common</c><00:20:41.720><c> for</c><00:20:42.520><c> our</c>

00:20:43.230 --> 00:20:43.240 align:start position:0%
case that uh was pretty common for our
 

00:20:43.240 --> 00:20:46.830 align:start position:0%
case that uh was pretty common for our
uh<00:20:43.400><c> initial</c><00:20:44.320><c> idea</c><00:20:44.760><c> of</c><00:20:44.880><c> Stack</c><00:20:45.520><c> validation</c><00:20:46.520><c> uh</c>

00:20:46.830 --> 00:20:46.840 align:start position:0%
uh initial idea of Stack validation uh
 

00:20:46.840 --> 00:20:49.630 align:start position:0%
uh initial idea of Stack validation uh
there<00:20:47.799><c> uh</c><00:20:48.080><c> the</c><00:20:48.240><c> optimization</c><00:20:49.000><c> that</c><00:20:49.159><c> I</c><00:20:49.280><c> meant</c>

00:20:49.630 --> 00:20:49.640 align:start position:0%
there uh the optimization that I meant
 

00:20:49.640 --> 00:20:52.990 align:start position:0%
there uh the optimization that I meant
was<00:20:50.360><c> uh</c><00:20:51.240><c> the</c><00:20:51.520><c> application</c><00:20:52.120><c> that</c><00:20:52.640><c> solidity</c>

00:20:52.990 --> 00:20:53.000 align:start position:0%
was uh the application that solidity
 

00:20:53.000 --> 00:20:55.230 align:start position:0%
was uh the application that solidity
compiler<00:20:53.400><c> does</c><00:20:53.679><c> when</c><00:20:53.799><c> it</c><00:20:53.880><c> sees</c><00:20:54.559><c> uh</c><00:20:54.720><c> a</c><00:20:54.919><c> similar</c>

00:20:55.230 --> 00:20:55.240 align:start position:0%
compiler does when it sees uh a similar
 

00:20:55.240 --> 00:20:58.590 align:start position:0%
compiler does when it sees uh a similar
code<00:20:55.559><c> at</c><00:20:55.799><c> at</c><00:20:56.000><c> multiple</c><00:20:56.919><c> uh</c><00:20:57.440><c> points</c><00:20:57.840><c> in</c><00:20:58.039><c> the</c>

00:20:58.590 --> 00:20:58.600 align:start position:0%
code at at multiple uh points in the
 

00:20:58.600 --> 00:21:00.669 align:start position:0%
code at at multiple uh points in the
bite<00:20:58.840><c> code</c><00:20:59.200><c> it</c><00:20:59.600><c> gets</c><00:20:59.880><c> them</c><00:21:00.039><c> and</c><00:21:00.200><c> distracts</c>

00:21:00.669 --> 00:21:00.679 align:start position:0%
bite code it gets them and distracts
 

00:21:00.679 --> 00:21:03.950 align:start position:0%
bite code it gets them and distracts
them<00:21:00.840><c> into</c><00:21:01.039><c> a</c><00:21:01.159><c> common</c><00:21:02.000><c> Helper</c><00:21:02.960><c> but</c><00:21:03.280><c> like</c><00:21:03.799><c> with</c>

00:21:03.950 --> 00:21:03.960 align:start position:0%
them into a common Helper but like with
 

00:21:03.960 --> 00:21:05.710 align:start position:0%
them into a common Helper but like with
the<00:21:04.480><c> first</c><00:21:04.760><c> algorithm</c><00:21:05.240><c> there</c><00:21:05.320><c> was</c><00:21:05.520><c> some</c>

00:21:05.710 --> 00:21:05.720 align:start position:0%
the first algorithm there was some
 

00:21:05.720 --> 00:21:07.510 align:start position:0%
the first algorithm there was some
overhead<00:21:06.360><c> and</c><00:21:06.600><c> in</c><00:21:06.720><c> the</c><00:21:06.840><c> end</c><00:21:07.080><c> this</c><00:21:07.200><c> might</c><00:21:07.400><c> not</c>

00:21:07.510 --> 00:21:07.520 align:start position:0%
overhead and in the end this might not
 

00:21:07.520 --> 00:21:09.270 align:start position:0%
overhead and in the end this might not
be<00:21:07.679><c> worth</c><00:21:07.840><c> it</c><00:21:08.039><c> and</c><00:21:08.320><c> because</c><00:21:08.640><c> code</c><00:21:08.919><c> size</c><00:21:09.120><c> in</c><00:21:09.200><c> the</c>

00:21:09.270 --> 00:21:09.280 align:start position:0%
be worth it and because code size in the
 

00:21:09.280 --> 00:21:12.070 align:start position:0%
be worth it and because code size in the
end<00:21:09.679><c> may</c><00:21:09.880><c> increase</c><00:21:10.400><c> and</c><00:21:10.640><c> gas</c><00:21:10.919><c> also</c>

00:21:12.070 --> 00:21:12.080 align:start position:0%
end may increase and gas also
 

00:21:12.080 --> 00:21:17.230 align:start position:0%
end may increase and gas also
increased<00:21:13.279><c> mhm</c><00:21:14.279><c> uh</c><00:21:14.559><c> so</c><00:21:15.480><c> uh</c><00:21:15.679><c> what</c><00:21:16.000><c> does</c><00:21:17.000><c> why</c>

00:21:17.230 --> 00:21:17.240 align:start position:0%
increased mhm uh so uh what does why
 

00:21:17.240 --> 00:21:20.549 align:start position:0%
increased mhm uh so uh what does why
does<00:21:17.520><c> this</c><00:21:17.760><c> need</c><00:21:18.320><c> needs</c><00:21:18.640><c> to</c><00:21:18.799><c> be</c><00:21:19.039><c> part</c><00:21:19.279><c> of</c><00:21:19.760><c> eof</c>

00:21:20.549 --> 00:21:20.559 align:start position:0%
does this need needs to be part of eof
 

00:21:20.559 --> 00:21:23.549 align:start position:0%
does this need needs to be part of eof
instead<00:21:21.000><c> of</c><00:21:21.520><c> just</c><00:21:21.840><c> relying</c><00:21:22.279><c> on</c><00:21:22.440><c> the</c><00:21:22.640><c> compiler</c>

00:21:23.549 --> 00:21:23.559 align:start position:0%
instead of just relying on the compiler
 

00:21:23.559 --> 00:21:25.909 align:start position:0%
instead of just relying on the compiler
to<00:21:23.880><c> H</c><00:21:24.400><c> uh</c><00:21:24.520><c> to</c><00:21:24.720><c> handle</c><00:21:25.120><c> stack</c><00:21:25.559><c> access</c>

00:21:25.909 --> 00:21:25.919 align:start position:0%
to H uh to handle stack access
 

00:21:25.919 --> 00:21:32.149 align:start position:0%
to H uh to handle stack access
efficiently

00:21:32.149 --> 00:21:32.159 align:start position:0%
 
 

00:21:32.159 --> 00:21:35.070 align:start position:0%
 
interesting

00:21:35.070 --> 00:21:35.080 align:start position:0%
interesting
 

00:21:35.080 --> 00:21:38.230 align:start position:0%
interesting
um<00:21:36.080><c> well</c><00:21:36.240><c> I</c><00:21:36.320><c> would</c>

00:21:38.230 --> 00:21:38.240 align:start position:0%
um well I would
 

00:21:38.240 --> 00:21:41.149 align:start position:0%
um well I would
say<00:21:39.240><c> there</c><00:21:39.360><c> is</c><00:21:39.480><c> a</c><00:21:39.679><c> value</c><00:21:40.039><c> definitely</c><00:21:40.880><c> some</c>

00:21:41.149 --> 00:21:41.159 align:start position:0%
say there is a value definitely some
 

00:21:41.159 --> 00:21:43.870 align:start position:0%
say there is a value definitely some
value<00:21:41.520><c> in</c><00:21:41.840><c> ensuring</c><00:21:42.760><c> St</c><00:21:43.159><c> correctness</c><00:21:43.640><c> of</c><00:21:43.760><c> the</c>

00:21:43.870 --> 00:21:43.880 align:start position:0%
value in ensuring St correctness of the
 

00:21:43.880 --> 00:21:45.149 align:start position:0%
value in ensuring St correctness of the
bite<00:21:44.120><c> code</c>

00:21:45.149 --> 00:21:45.159 align:start position:0%
bite code
 

00:21:45.159 --> 00:21:48.669 align:start position:0%
bite code
itself<00:21:46.159><c> uh</c><00:21:46.279><c> because</c><00:21:46.640><c> it</c><00:21:46.919><c> can</c><00:21:47.919><c> it</c><00:21:48.200><c> bite</c><00:21:48.480><c> code</c>

00:21:48.669 --> 00:21:48.679 align:start position:0%
itself uh because it can it bite code
 

00:21:48.679 --> 00:21:50.470 align:start position:0%
itself uh because it can it bite code
itself<00:21:49.080><c> then</c><00:21:49.279><c> can</c><00:21:49.440><c> be</c><00:21:49.600><c> audited</c><00:21:50.080><c> or</c><00:21:50.240><c> can</c><00:21:50.360><c> be</c>

00:21:50.470 --> 00:21:50.480 align:start position:0%
itself then can be audited or can be
 

00:21:50.480 --> 00:21:52.070 align:start position:0%
itself then can be audited or can be
formally<00:21:50.880><c> verified</c><00:21:51.279><c> or</c><00:21:51.400><c> can</c><00:21:51.520><c> be</c><00:21:51.640><c> statically</c>

00:21:52.070 --> 00:21:52.080 align:start position:0%
formally verified or can be statically
 

00:21:52.080 --> 00:21:54.909 align:start position:0%
formally verified or can be statically
analyzed<00:21:52.679><c> so</c><00:21:53.360><c> St</c><00:21:53.679><c> validation</c><00:21:54.159><c> and</c><00:21:54.480><c> validation</c>

00:21:54.909 --> 00:21:54.919 align:start position:0%
analyzed so St validation and validation
 

00:21:54.919 --> 00:21:58.630 align:start position:0%
analyzed so St validation and validation
in<00:21:55.200><c> general</c><00:21:56.200><c> uh</c><00:21:56.679><c> uh</c><00:21:57.000><c> simplifies</c><00:21:57.799><c> these</c><00:21:58.000><c> tasks</c>

00:21:58.630 --> 00:21:58.640 align:start position:0%
in general uh uh simplifies these tasks
 

00:21:58.640 --> 00:22:02.350 align:start position:0%
in general uh uh simplifies these tasks
and<00:21:59.159><c> uh</c><00:21:59.840><c> uh</c><00:22:00.000><c> immensely</c><00:22:00.480><c> I</c><00:22:00.559><c> would</c><00:22:00.720><c> say</c><00:22:01.360><c> so</c>

00:22:02.350 --> 00:22:02.360 align:start position:0%
and uh uh immensely I would say so
 

00:22:02.360 --> 00:22:03.789 align:start position:0%
and uh uh immensely I would say so
that's<00:22:02.520><c> the</c><00:22:02.679><c> answer</c><00:22:02.960><c> I</c><00:22:03.039><c> think</c><00:22:03.240><c> so</c><00:22:03.520><c> if</c><00:22:03.640><c> it</c>

00:22:03.789 --> 00:22:03.799 align:start position:0%
that's the answer I think so if it
 

00:22:03.799 --> 00:22:06.549 align:start position:0%
that's the answer I think so if it
wouldn't<00:22:04.039><c> be</c><00:22:04.159><c> enforced</c><00:22:04.600><c> on</c><00:22:04.840><c> the</c><00:22:05.640><c> protocol</c>

00:22:06.549 --> 00:22:06.559 align:start position:0%
wouldn't be enforced on the protocol
 

00:22:06.559 --> 00:22:08.430 align:start position:0%
wouldn't be enforced on the protocol
level

00:22:08.430 --> 00:22:08.440 align:start position:0%
level
 

00:22:08.440 --> 00:22:13.190 align:start position:0%
level
then<00:22:09.440><c> high</c><00:22:09.679><c> level</c><00:22:10.440><c> uh</c><00:22:11.000><c> the</c><00:22:11.200><c> same</c><00:22:12.200><c> only</c><00:22:12.720><c> the</c>

00:22:13.190 --> 00:22:13.200 align:start position:0%
then high level uh the same only the
 

00:22:13.200 --> 00:22:15.950 align:start position:0%
then high level uh the same only the
high<00:22:13.400><c> level</c><00:22:13.679><c> Lang</c><00:22:13.960><c> language</c><00:22:14.559><c> code</c><00:22:14.960><c> would</c><00:22:15.200><c> be</c>

00:22:15.950 --> 00:22:15.960 align:start position:0%
high level Lang language code would be
 

00:22:15.960 --> 00:22:17.149 align:start position:0%
high level Lang language code would be
available

00:22:17.149 --> 00:22:17.159 align:start position:0%
available
 

00:22:17.159 --> 00:22:20.630 align:start position:0%
available
to<00:22:18.159><c> uh</c><00:22:18.559><c> to</c><00:22:18.720><c> use</c><00:22:19.039><c> these</c><00:22:19.279><c> benefits</c><00:22:19.760><c> I</c><00:22:19.840><c> think</c>

00:22:20.630 --> 00:22:20.640 align:start position:0%
to uh to use these benefits I think
 

00:22:20.640 --> 00:22:26.909 align:start position:0%
to uh to use these benefits I think
Soh<00:22:21.640><c> makes</c><00:22:22.360><c> sense</c><00:22:23.760><c> uh</c><00:22:24.760><c> so</c><00:22:25.240><c> the</c><00:22:25.440><c> next</c><00:22:25.720><c> one</c><00:22:26.240><c> is</c><00:22:26.679><c> uh</c>

00:22:26.909 --> 00:22:26.919 align:start position:0%
Soh makes sense uh so the next one is uh
 

00:22:26.919 --> 00:22:29.830 align:start position:0%
Soh makes sense uh so the next one is uh
if<00:22:27.120><c> the</c><00:22:27.279><c> code</c><00:22:27.679><c> passes</c><00:22:28.279><c> uh</c><00:22:28.640><c> stock</c><00:22:28.919><c> range</c>

00:22:29.830 --> 00:22:29.840 align:start position:0%
if the code passes uh stock range
 

00:22:29.840 --> 00:22:32.669 align:start position:0%
if the code passes uh stock range
validation<00:22:30.840><c> um</c><00:22:31.440><c> is</c><00:22:31.559><c> it</c><00:22:31.840><c> possible</c><00:22:32.360><c> that</c><00:22:32.559><c> there</c>

00:22:32.669 --> 00:22:32.679 align:start position:0%
validation um is it possible that there
 

00:22:32.679 --> 00:22:37.029 align:start position:0%
validation um is it possible that there
is<00:22:32.799><c> a</c><00:22:33.000><c> code</c><00:22:33.360><c> path</c><00:22:33.840><c> that</c><00:22:34.520><c> under</c><00:22:35.080><c> overflows</c><00:22:35.840><c> the</c>

00:22:37.029 --> 00:22:37.039 align:start position:0%
is a code path that under overflows the
 

00:22:37.039 --> 00:22:39.789 align:start position:0%
is a code path that under overflows the
stock<00:22:38.039><c> there</c><00:22:38.159><c> is</c><00:22:38.679><c> uh</c><00:22:39.120><c> possibility</c><00:22:39.640><c> of</c>

00:22:39.789 --> 00:22:39.799 align:start position:0%
stock there is uh possibility of
 

00:22:39.799 --> 00:22:41.990 align:start position:0%
stock there is uh possibility of
overflows<00:22:40.360><c> but</c><00:22:40.520><c> not</c><00:22:40.679><c> underflows</c><00:22:41.520><c> that's</c><00:22:41.840><c> the</c>

00:22:41.990 --> 00:22:42.000 align:start position:0%
overflows but not underflows that's the
 

00:22:42.000 --> 00:22:45.149 align:start position:0%
overflows but not underflows that's the
answer<00:22:42.400><c> yeah</c><00:22:42.799><c> um</c><00:22:43.799><c> underflows</c><00:22:44.360><c> are</c><00:22:44.520><c> completely</c>

00:22:45.149 --> 00:22:45.159 align:start position:0%
answer yeah um underflows are completely
 

00:22:45.159 --> 00:22:47.470 align:start position:0%
answer yeah um underflows are completely
eliminated<00:22:45.760><c> thanks</c><00:22:46.000><c> to</c><00:22:46.240><c> static</c><00:22:46.840><c> validation</c>

00:22:47.470 --> 00:22:47.480 align:start position:0%
eliminated thanks to static validation
 

00:22:47.480 --> 00:22:51.549 align:start position:0%
eliminated thanks to static validation
at<00:22:47.760><c> at</c><00:22:48.240><c> uh</c><00:22:49.000><c> deployment</c><00:22:49.559><c> time</c><00:22:49.919><c> and</c><00:22:50.559><c> overflows</c>

00:22:51.549 --> 00:22:51.559 align:start position:0%
at at uh deployment time and overflows
 

00:22:51.559 --> 00:22:54.029 align:start position:0%
at at uh deployment time and overflows
still<00:22:51.840><c> can</c><00:22:52.080><c> happen</c><00:22:52.760><c> but</c><00:22:53.320><c> uh</c><00:22:53.440><c> we</c><00:22:53.600><c> do</c><00:22:53.760><c> not</c><00:22:53.919><c> need</c>

00:22:54.029 --> 00:22:54.039 align:start position:0%
still can happen but uh we do not need
 

00:22:54.039 --> 00:22:56.470 align:start position:0%
still can happen but uh we do not need
to<00:22:54.159><c> check</c><00:22:54.400><c> them</c><00:22:54.520><c> at</c><00:22:54.640><c> every</c><00:22:54.799><c> instruction</c><00:22:55.279><c> as</c><00:22:55.480><c> I</c>

00:22:56.470 --> 00:22:56.480 align:start position:0%
to check them at every instruction as I
 

00:22:56.480 --> 00:23:01.830 align:start position:0%
to check them at every instruction as I
as<00:22:56.559><c> I</c><00:22:56.760><c> said</c><00:22:57.360><c> mhm</c><00:22:58.320><c> uh</c><00:22:58.840><c> uh</c><00:22:59.400><c> and</c><00:23:00.360><c> um</c><00:23:01.360><c> the</c><00:23:01.520><c> next</c>

00:23:01.830 --> 00:23:01.840 align:start position:0%
as I said mhm uh uh and um the next
 

00:23:01.840 --> 00:23:07.070 align:start position:0%
as I said mhm uh uh and um the next
question<00:23:02.279><c> is</c><00:23:02.799><c> uh</c><00:23:03.400><c> if</c><00:23:03.919><c> St</c><00:23:04.919><c> validation</c><00:23:05.640><c> makes</c><00:23:06.320><c> uh</c>

00:23:07.070 --> 00:23:07.080 align:start position:0%
question is uh if St validation makes uh
 

00:23:07.080 --> 00:23:10.470 align:start position:0%
question is uh if St validation makes uh
ZK<00:23:07.600><c> cross</c><00:23:07.919><c> compilation</c><00:23:08.679><c> or</c><00:23:09.000><c> ZK</c><00:23:10.000><c> Trace</c>

00:23:10.470 --> 00:23:10.480 align:start position:0%
ZK cross compilation or ZK Trace
 

00:23:10.480 --> 00:23:13.470 align:start position:0%
ZK cross compilation or ZK Trace
aromatization<00:23:11.480><c> easier</c><00:23:11.840><c> or</c>

00:23:13.470 --> 00:23:13.480 align:start position:0%
aromatization easier or
 

00:23:13.480 --> 00:23:16.430 align:start position:0%
aromatization easier or
harder<00:23:14.480><c> it</c><00:23:14.840><c> definitely</c><00:23:15.279><c> makes</c><00:23:15.480><c> it</c><00:23:15.640><c> easier</c><00:23:16.200><c> if</c>

00:23:16.430 --> 00:23:16.440 align:start position:0%
harder it definitely makes it easier if
 

00:23:16.440 --> 00:23:20.430 align:start position:0%
harder it definitely makes it easier if
in<00:23:16.640><c> case</c><00:23:17.240><c> this</c><00:23:17.520><c> ZK</c><00:23:17.919><c> compilation</c><00:23:18.600><c> targets</c><00:23:19.440><c> eof</c>

00:23:20.430 --> 00:23:20.440 align:start position:0%
in case this ZK compilation targets eof
 

00:23:20.440 --> 00:23:22.909 align:start position:0%
in case this ZK compilation targets eof
only<00:23:20.760><c> eof</c><00:23:21.159><c> and</c><00:23:21.559><c> does</c><00:23:21.760><c> not</c><00:23:21.960><c> try</c><00:23:22.159><c> to</c><00:23:22.480><c> support</c>

00:23:22.909 --> 00:23:22.919 align:start position:0%
only eof and does not try to support
 

00:23:22.919 --> 00:23:25.990 align:start position:0%
only eof and does not try to support
Legacy<00:23:23.320><c> 2</c><00:23:23.600><c> in</c><00:23:23.760><c> case</c><00:23:24.240><c> it</c><00:23:24.360><c> is</c><00:23:25.039><c> ZK</c><00:23:25.559><c> system</c><00:23:25.880><c> that</c>

00:23:25.990 --> 00:23:26.000 align:start position:0%
Legacy 2 in case it is ZK system that
 

00:23:26.000 --> 00:23:28.149 align:start position:0%
Legacy 2 in case it is ZK system that
tries<00:23:26.240><c> to</c><00:23:26.400><c> support</c><00:23:26.799><c> both</c><00:23:27.200><c> Legacy</c><00:23:27.559><c> execution</c>

00:23:28.149 --> 00:23:28.159 align:start position:0%
tries to support both Legacy execution
 

00:23:28.159 --> 00:23:31.190 align:start position:0%
tries to support both Legacy execution
and<00:23:28.880><c> UF</c><00:23:29.320><c> execution</c><00:23:29.919><c> then</c><00:23:30.600><c> it</c><00:23:30.760><c> has</c><00:23:30.919><c> to</c>

00:23:31.190 --> 00:23:31.200 align:start position:0%
and UF execution then it has to
 

00:23:31.200 --> 00:23:32.950 align:start position:0%
and UF execution then it has to
basically<00:23:31.559><c> support</c><00:23:31.919><c> two</c><00:23:32.080><c> different</c><00:23:32.400><c> systems</c>

00:23:32.950 --> 00:23:32.960 align:start position:0%
basically support two different systems
 

00:23:32.960 --> 00:23:35.870 align:start position:0%
basically support two different systems
that<00:23:33.120><c> is</c><00:23:33.679><c> big</c><00:23:33.919><c> pain</c><00:23:34.159><c> I</c><00:23:34.320><c> guess</c><00:23:34.600><c> so</c><00:23:35.440><c> it's</c>

00:23:35.870 --> 00:23:35.880 align:start position:0%
that is big pain I guess so it's
 

00:23:35.880 --> 00:23:39.590 align:start position:0%
that is big pain I guess so it's
generally<00:23:36.640><c> much</c><00:23:37.640><c> better</c><00:23:38.039><c> idea</c><00:23:38.400><c> to</c><00:23:38.600><c> support</c><00:23:39.000><c> EF</c>

00:23:39.590 --> 00:23:39.600 align:start position:0%
generally much better idea to support EF
 

00:23:39.600 --> 00:23:42.350 align:start position:0%
generally much better idea to support EF
for<00:23:39.840><c> them</c><00:23:40.200><c> and</c><00:23:40.720><c> uh</c>

00:23:42.350 --> 00:23:42.360 align:start position:0%
for them and uh
 

00:23:42.360 --> 00:23:46.430 align:start position:0%
for them and uh
then<00:23:43.360><c> thanks</c><00:23:43.760><c> to</c><00:23:44.760><c> code</c><00:23:45.200><c> validation</c><00:23:46.200><c> and</c>

00:23:46.430 --> 00:23:46.440 align:start position:0%
then thanks to code validation and
 

00:23:46.440 --> 00:23:49.110 align:start position:0%
then thanks to code validation and
thanks<00:23:46.679><c> to</c><00:23:47.480><c> uh</c><00:23:47.600><c> deleting</c><00:23:48.080><c> code</c><00:23:48.320><c> observability</c>

00:23:49.110 --> 00:23:49.120 align:start position:0%
thanks to uh deleting code observability
 

00:23:49.120 --> 00:23:52.029 align:start position:0%
thanks to uh deleting code observability
ZK<00:23:49.799><c> compilation</c><00:23:50.480><c> becomes</c><00:23:51.159><c> much</c><00:23:51.360><c> easier</c>

00:23:52.029 --> 00:23:52.039 align:start position:0%
ZK compilation becomes much easier
 

00:23:52.039 --> 00:23:54.230 align:start position:0%
ZK compilation becomes much easier
that's<00:23:52.640><c> at</c><00:23:52.760><c> least</c><00:23:53.039><c> the</c><00:23:53.200><c> theory</c><00:23:53.679><c> and</c><00:23:54.120><c> yeah</c>

00:23:54.230 --> 00:23:54.240 align:start position:0%
that's at least the theory and yeah
 

00:23:54.240 --> 00:23:55.830 align:start position:0%
that's at least the theory and yeah
we'll<00:23:54.400><c> see</c><00:23:54.600><c> how</c><00:23:54.760><c> this</c><00:23:54.919><c> works</c>

00:23:55.830 --> 00:23:55.840 align:start position:0%
we'll see how this works
 

00:23:55.840 --> 00:24:00.590 align:start position:0%
we'll see how this works
out<00:23:56.840><c> okay</c><00:23:57.080><c> and</c><00:23:57.600><c> uh</c><00:23:57.960><c> I</c><00:23:58.080><c> guess</c><00:23:58.440><c> last</c><00:23:58.679><c> question</c><00:23:59.640><c> uh</c>

00:24:00.590 --> 00:24:00.600 align:start position:0%
out okay and uh I guess last question uh
 

00:24:00.600 --> 00:24:03.310 align:start position:0%
out okay and uh I guess last question uh
will<00:24:01.440><c> gas</c><00:24:01.720><c> fee</c><00:24:02.240><c> reduce</c><00:24:02.880><c> after</c><00:24:03.120><c> the</c>

00:24:03.310 --> 00:24:03.320 align:start position:0%
will gas fee reduce after the
 

00:24:03.320 --> 00:24:05.510 align:start position:0%
will gas fee reduce after the
optimization<00:24:04.200><c> and</c><00:24:04.400><c> if</c><00:24:04.559><c> so</c><00:24:04.799><c> how</c><00:24:05.000><c> much</c><00:24:05.440><c> there</c>

00:24:05.510 --> 00:24:05.520 align:start position:0%
optimization and if so how much there
 

00:24:05.520 --> 00:24:08.470 align:start position:0%
optimization and if so how much there
was<00:24:05.640><c> no</c><00:24:05.840><c> exact</c><00:24:06.080><c> plans</c><00:24:06.400><c> to</c><00:24:06.559><c> reduce</c><00:24:07.000><c> gas</c><00:24:07.640><c> but</c><00:24:08.279><c> uh</c>

00:24:08.470 --> 00:24:08.480 align:start position:0%
was no exact plans to reduce gas but uh
 

00:24:08.480 --> 00:24:12.549 align:start position:0%
was no exact plans to reduce gas but uh
we<00:24:08.880><c> definitely</c><00:24:09.360><c> will</c><00:24:09.919><c> see</c><00:24:11.039><c> some</c><00:24:12.039><c> uh</c>

00:24:12.549 --> 00:24:12.559 align:start position:0%
we definitely will see some uh
 

00:24:12.559 --> 00:24:15.630 align:start position:0%
we definitely will see some uh
improvements<00:24:13.120><c> in</c><00:24:14.039><c> in</c><00:24:14.400><c> in</c><00:24:14.640><c> execution</c><00:24:15.080><c> time</c><00:24:15.480><c> and</c>

00:24:15.630 --> 00:24:15.640 align:start position:0%
improvements in in in execution time and
 

00:24:15.640 --> 00:24:17.070 align:start position:0%
improvements in in in execution time and
this<00:24:15.799><c> might</c><00:24:16.000><c> lead</c><00:24:16.200><c> to</c><00:24:16.279><c> some</c><00:24:16.440><c> optimizations</c><00:24:16.960><c> in</c>

00:24:17.070 --> 00:24:17.080 align:start position:0%
this might lead to some optimizations in
 

00:24:17.080 --> 00:24:17.789 align:start position:0%
this might lead to some optimizations in
the

00:24:17.789 --> 00:24:17.799 align:start position:0%
the
 

00:24:17.799 --> 00:24:21.310 align:start position:0%
the
future<00:24:18.799><c> uh</c><00:24:19.559><c> there</c><00:24:19.720><c> will</c><00:24:19.919><c> be</c><00:24:20.360><c> gas</c><00:24:20.760><c> savings</c>

00:24:21.310 --> 00:24:21.320 align:start position:0%
future uh there will be gas savings
 

00:24:21.320 --> 00:24:23.269 align:start position:0%
future uh there will be gas savings
thanks<00:24:21.600><c> to</c><00:24:22.000><c> better</c><00:24:22.400><c> stack</c><00:24:22.640><c> management</c><00:24:23.159><c> this</c>

00:24:23.269 --> 00:24:23.279 align:start position:0%
thanks to better stack management this
 

00:24:23.279 --> 00:24:26.070 align:start position:0%
thanks to better stack management this
is<00:24:23.559><c> like</c><00:24:23.720><c> not</c><00:24:24.520><c> uh</c><00:24:24.720><c> specifically</c><00:24:25.159><c> related</c><00:24:25.520><c> to</c>

00:24:26.070 --> 00:24:26.080 align:start position:0%
is like not uh specifically related to
 

00:24:26.080 --> 00:24:28.110 align:start position:0%
is like not uh specifically related to
validation<00:24:26.760><c> but</c><00:24:27.039><c> rather</c><00:24:27.320><c> to</c><00:24:27.480><c> a</c><00:24:27.640><c> better</c><00:24:27.960><c> just</c>

00:24:28.110 --> 00:24:28.120 align:start position:0%
validation but rather to a better just
 

00:24:28.120 --> 00:24:29.710 align:start position:0%
validation but rather to a better just
better<00:24:28.399><c> instruction</c><00:24:29.039><c> instructions</c><00:24:29.520><c> to</c>

00:24:29.710 --> 00:24:29.720 align:start position:0%
better instruction instructions to
 

00:24:29.720 --> 00:24:32.190 align:start position:0%
better instruction instructions to
handle<00:24:30.320><c> values</c><00:24:30.640><c> on</c><00:24:30.880><c> stack</c><00:24:31.480><c> uh</c><00:24:31.799><c> we</c><00:24:31.919><c> have</c><00:24:32.080><c> now</c>

00:24:32.190 --> 00:24:32.200 align:start position:0%
handle values on stack uh we have now
 

00:24:32.200 --> 00:24:34.590 align:start position:0%
handle values on stack uh we have now
Swap<00:24:32.520><c> and</c><00:24:32.720><c> d</c><00:24:32.919><c> and</c><00:24:33.200><c> and</c><00:24:33.520><c> exchange</c><00:24:34.080><c> and</c><00:24:34.320><c> all</c>

00:24:34.590 --> 00:24:34.600 align:start position:0%
Swap and d and and exchange and all
 

00:24:34.600 --> 00:24:37.470 align:start position:0%
Swap and d and and exchange and all
these<00:24:35.600><c> uh</c><00:24:35.880><c> simplifies</c><00:24:36.520><c> life</c><00:24:36.679><c> for</c><00:24:36.840><c> compilers</c>

00:24:37.470 --> 00:24:37.480 align:start position:0%
these uh simplifies life for compilers
 

00:24:37.480 --> 00:24:39.710 align:start position:0%
these uh simplifies life for compilers
and<00:24:37.919><c> in</c><00:24:38.039><c> the</c><00:24:38.159><c> end</c><00:24:38.480><c> reduces</c><00:24:38.960><c> gas</c><00:24:39.200><c> consumed</c><00:24:39.559><c> for</c>

00:24:39.710 --> 00:24:39.720 align:start position:0%
and in the end reduces gas consumed for
 

00:24:39.720 --> 00:24:40.750 align:start position:0%
and in the end reduces gas consumed for
entire

00:24:40.750 --> 00:24:40.760 align:start position:0%
entire
 

00:24:40.760 --> 00:24:44.389 align:start position:0%
entire
execution<00:24:41.760><c> great</c><00:24:42.080><c> how</c><00:24:42.200><c> much</c><00:24:42.360><c> can</c><00:24:42.480><c> I</c><00:24:43.159><c> say</c><00:24:44.159><c> uh</c>

00:24:44.389 --> 00:24:44.399 align:start position:0%
execution great how much can I say uh
 

00:24:44.399 --> 00:24:48.000 align:start position:0%
execution great how much can I say uh
let's<00:24:44.679><c> thanks</c><00:24:45.279><c> um</c>

