►
From YouTube: ECDC - DAY 2: eWASM Session by Alex Beregszaszi
Description
No description was provided for this meeting.
If this is YOUR meeting, an easy way to fix this is to add a description to your video, wherever mtngs.io found it (probably YouTube).
A
A
C
A
A
A
A
Of
it
was,
and
who
hasn't
heard
about,
he
was
on
ok,
so
maybe
we
don't
need
to
do
a
lot
of
introduction
yeah,
but
it's
it's
designed
by
the
w3c,
but
it's
really
open
anybody
can
contribute.
They
have
I
think
like
twice
year,
maybe
three
times
a
year,
a
panel
where
people
can
join
and
they
can
open
new
contributions.
They
can
propose
like
major
changes
to
the
language
and
that
can
be
discussed.
But
apart
from
those
in-person
meetings,
anybody
can
contribute
on
the
github
design
Vito.
They
have.
A
It
was
finalized
yeah
last
year,
and
but
there
are
already
I
guess
like
four
or
five
major
proposals
to
extend
it
and
extension
is
backwards
compatible.
So
whatever
new
feature
comes
into
awesome,
the
the
clients
can
make
a
decision,
but
they
didn't
want
to
support
it
or
not,
and
it
kind
of
looks
like
a
regular
machine.
It's
not
as
exotic
as
DTM
is.
It
is
really
a
regular
machine.
The
main
goal
is
to
efficiently
translated
to
a
native
machine
that
was
the
main
driving
goal
behind
wazzle.
A
It
doesn't
have
any
such
high
level
super
high
level
instructions
as
chantry.
Instead,
bytecode
can
import
host
functions
and
that's
a
way
to
extend
the
language
which,
more
with
more
complex
things,
it's
supported
by
all
the
major
browsers,
but
there
are
also
a
lot
of
independent
implementations
outside
of
the
browsers
and
I
guess.
This
is
the
more
important
part
because
it
always
comes
up.
A
It
wasn't
be
gonna,
have
a
lot
of
support
for
different
languages
and
that's
true
I've
sorted
these
languages
in
terms
of
maturity
of
the
tooling,
and
basically,
we
can
start
with
anything
supported
by
LLVM.
So
LLVM
would
be
a
compiler
framework
and
the
most
mature
languages
or
was
an
idea,
is
CN
C++.
But
maybe
you
don't
really
want
to
use
that
for
contracts
and
the
next,
which
probably
is
at
the
same
level
of
maturity,
would
be
rust.
It
doesn't
think
it
does
or
doesn't
use
all
of
the
young
I
think.
A
A
There
are
some
tools
to
remove
extra
code
from
one
bytecode
which
isn't
referenced.
The
multiple
tools
one
of
them
is
called,
was
MTC
and
one
it
wasn't
easy
and
it
would
reduce
it
I
think
to
500k,
but
there
was
one
part
in
it
which
couldn't
be
removed.
It
pre
defines
a
500k
memory
segment
with
stuff
in
it,
so
maybe
in
the
future,
goat
would
be
supported,
but
right
now
it
doesn't
seem
like
a
good
target
for
contract.
A
There's
also
a
Haskell
compiler
called
DHC,
but
it's
really
minimal.
It
doesn't
support
a
lot
of
features
here.
It's
driven
by
definitive.
If
you
have
heard
about
definitely
the
next
one
is
solidity,
and
there
is
another
language
next
week.
You'll
has
anybody
in
word
with
you,
yeah
three
people
have
you
heard
with
Julian?
A
Have
you
heard
about
the
Julia
which
isn't
the
big
Julian,
the
Scala
Julia,
alright,
so
Jules?
That
Julia
is
intermediate
language
of
solidity.
It
was
called
Julian
last
year,
but
it
conflicts
with
another
language.
For
Julia-
and
it
has
been
renamed
to
you,
so
it's
it's-
the
proposed
IR
of
solidity.
A
There
is
actually
a
proper
parcel
and
compiler
from
you
to
evm,
1.0
and
even
1.5,
and
there's
also
support
to
compile
you
to
wasa,
but
there's
a
big
part
which
isn't
there
yet
to
compile
solidity
to
you.
That
being
said,
we
do
use
you'll
for
some
internal
snippets
in
a
compiler
already.
Have
you
heard
about
the
ten
you
sorry,
the
new
ABI
encoder
in
solidity.
A
Okay,
so
basically
there,
the
ABI
is
a
way
to
interface
with
contracts,
and
so
lady
T
has
it
implemented
in
really
bad
citrus
pass
code
to
generate
to
see
if
ABI,
ten
coda,
which
is
injected
in
each
of
the
contracts.
That
is
one
of
the
big
parts
of
what
should
be
obtained
immediate
language
and
that's.
We
actually
have
worthy
rewritten
using
you'll,
and
that
is
the
new
ABI
encoder.
It's
called
ABI
encoder
b2.
A
It
can
be
enabled
in
the
language
using
an
experimental
partner
and
we
would
like
to
get
basically,
we
have
no
idea
yet
had
to
get
people
to
test
it,
because
it's
an
expected
smart,
this
an
experimental
feature.
We
would
like
to
believe
people
depend
on
it
because
they
want
to
use
structures
and
high-level
datatypes.
That's
only
supported
by
to
say
the
eye
decoder.
A
So
I
guess
wiper
still
have
multiple
options
to
target
wasn't,
but
one
of
them
would
be
to
target
you
as
an
intermediate
language
and
then
make
use
of
you
to
compile
it
to
web
assembly.
And
and
lastly,
there
is
a
lot
of
work
on
indication.
Work
to
support
was
in
there
to
support.
He
wasn't.
So
that's
a
lot
of
languages
already
on
probably
I
pissed,
a
ton
of
other
languages,
because
they're
popping
up
every
day.
E
C
C
C
A
C
A
A
These
host
functions
all
these
features
exposed
to.
He
wasn't
contracts
which
are
made
available
to
EVM
as
higher
level
instructions.
So
it
has
all
the
same
kind
of
calls.
It
has
all
the
same
kind
of
storage
access.
It
is
all
the
same
kind
of
state
back
stairs
and
at
least
it's
possible
to
write
about
some
contracts
with
which
can
hundred
percent
interact
with
EVM
contracts.
A
But
it's
it
has
been
designed
to
be
extensible,
so
we
can
remove
some
of
those
and
they
can
ideal
ones,
and
it's
really
important,
because
even
though
it
started
out
as
a
hundred
percent
compatibility
bttm
with
the
goal
to
launch
it
on
the
main
chain.
But
if
we
decide
to
not
launch
it
on
the
main
chain,
maybe
we
can
improve
some
of
these
and
remove
some
of
the
vault
methods
which
don't
make
any
sense
anymore.
A
A
The
current
state,
the
API,
is
stable,
there's
IBM
compatible
API
and
we
have
quite
a
few
ways
to
support
clients.
So
the
native
one
is
a
cpdt,
reom
and
they're
going
to
be
a
more
extensive
talk
after
this.
At
this
topic,
there's
also
native
supporting
material
again
they're
going
to
be
a
talk
about
that
and
there's
in
progress,
work
at
IBM,
/,
printing,
again
I
talked
about
that
later,
but
there's
also
Universal
Universal
way
to
support
one
of
these
implementations
in
any
client
by
implementing
the
same
API
and
big
an
exponent
that
later
as
well.
A
A
A
The
other
things
we
are
currently
focusing
on
is
more
research
thanks,
researching
on
vulnerabilities,
one
of
them
is
regarding
tips.
A
lot
of
questions
have
been
raised
around
jets
and
we
try
to
address
all
of
those
questions
and
they're
gonna
be
a
talk
about
this
today
and
we're
trying
to
help
like
solidity
and
Viper
to
support
velocity.
A
They
still
had
to
participate.
We
have
a
bi-weekly
community
call
which
is
open
to
anyone.
We
have
been
product
that
I
think
for
the
last
two
months
and
there
has
been
a
lot
of
people
joining
usually
in
the
range
of
ten
to
thirty
people.
Each
for
anybody
can
join.
They
can
ask
any
kind
of
questions.
A
It's
fully
free,
there's
a
page
to
put
agenda
points,
but
nobody
ever
does
that,
but
it's
still
at
work
site,
but
now
we're
gonna
start
a
developer
call
as
well
to
make
decisions
72
weeks
and
the
next
one
is
the
fifth
of
July,
which
is
Thursday
whatever
its
next
week.
That
is
free
to
participate
as
well.
We
do
have
a
chat,
the
points
there
and
does
agenda
points
we
would
like
to
make
decisions
on.
Maybe
we
can
make
decisions
from
the
first
of
all,
probably
not,
but
I
invite
everyone
to
join.
A
Please
tweet
us
back
and
comment
get
this
kind
of
Stables.
It
can
be
discussed
and
it's
stable
to
be
changed
and
please
write
the
contracts.
So
they're
gonna
be
a
challenge
posted
here.
Okay,
so
probably
everybody
knows
about
these
URLs.
Just
please
join
the
Gator
channel
and
you're
gonna
be
updated
with
all
of
these
progress.
We're
making.
A
A
This
is
like
the
magic
magical,
gas
calculation
we
do
in
pecan,
pies
and
lastly,
but
the
finish
date
of
your
history
returning
the
calculated
hash,
so
whoever
anything
connected
to
chateau
five
six,
we
compile
probably
has
done
the
very
same
things
already.
If
you
get
to
use
he
wasn't,
you
may
not
need
to
do
it
again.
You
could
just
compile
this
snippet
and
use
it
any
questions
on
this
dippin
yeah.
A
Dependence,
so
if
we
keep
this
magical
gas
calculation,
they
pick
on
myself,
because
the
pecan
pies
have
like
a
random
number
assigned
to
them,
how
much
they
cost
right
and
if
we,
if
it
just
meter
this
contract,
how
we
would
meet
or
anything
else
in
he
wasn't,
then
probably
it
would
come
up
with
a
different
cost.
If
you
have
to
accept
that,
then
you
don't
need
that
line.
A
A
A
A
H
H
H
H
So
one
of
the
nice
things
about
the
rust
webassembly
tool
chain
is,
it
does
produce.
It
does
generate
nice,
small
binaries.
So
this
is
the
the
assembly.
So
you
can
see
it's
converted
into
these
import
statements
and
then
we
do
have
to
change
the
env2
aetherium.
There's
no
option
to
do
that
in
the
rust
webassembly
compiler.
So
we
have
to
do
that.
There's
a
post
processing
step.
H
E
Also
bear
with
me
because
I
don't
I,
didn't
sleep
on
my
plate
and
I'm
like
super
jet
lag,
so
I'll
just
keep
this
brief.
So
look
I
think
like
languages
like
rust
and
go
scene.
C++
are
great,
but
speaking
as
someone
who
has
a
background
as
a
full
stack
web
developer
and
also
kind
of
like
looking
to
the
future
of
etherium
in
trying
to
make,
you
know,
make
it
into
a
platformer
that
I
think
will
appeal
to
masses
of
developers.
E
It
basically,
basically
just
adds
strict
typing
to
JavaScript
assembly
script.
Has
some
restrictions
assembly
script
strictly
speaking,
is
not
a
language
itself.
It's
as
I
said
sort
of
just
this
restricted
subset
of
typescript.
It
has
some
restrictions
like
typescript,
allows
I
think
it's
called
in
any
type
which
what
I
guess
have
some
sort
of
type
inference
happening,
because
typescript
is
still
running
inside
the
JavaScript
runtime
assembly
script
is
not
needless
to
say,
right.
E
E
That's
pretty
exciting,
so,
just
kind
of
looking
at
what
this
code
looks
like.
It
should
look
a
little
bit
like
JavaScript.
The
one
thing
that
like
really
stands
out
is
to
me
at
least,
is
that
we're
still
doing
some
memory
allocation
and
we're
still
working
with
pointers
here.
So
what
you're
looking
at
here
is
native
assembly
script.
I
didn't
have
too
much
trouble
with
this,
because
this
is
we've
been.
E
Writing
wast,
which
is
the
text
version
of
of
web
assembly
by
hand
for
months,
and
so
this
is
sort
of,
like
you
know,
after
slogging,
through
the
sort
of
dense,
deep
jungle
which
is
like
lost,
it's
like
we're
now
at
one
level
or
two
levels
of
abstraction
higher,
which
is
really
really
nice.
So
it's
you
know.
Basically,
my
goal
here
is
is
is
well.
E
We
have
to
do
this
sort
of
memory
allocation
and
we
have
to
work
with
pointers,
and
the
reason
for
that
is
that
these
calls,
of
example,
is
called
a
to
copy
here
right.
This
is
a
call
directly
into
the
host
function
in
this
case
right,
so
called
data
copy,
obviously
you
know
is-
is-
is
reading
into
this
pointer
here,
a
certain
number
of
bytes
from
the
the
call
data
that
was
passed
in
to
this
function
weight.
E
This
is
this
is
still
a
little
bit
too
low-level,
because
we
have
point
tourism,
because
we
have
memory
allocation
and
loading
and
storing
memory
directly.
So
I
guess
my
goal
here,
something
that
both
Alex
and
I
have
been
working
on
is
to
move
get
one
level
higher
at
the
abstraction.
Here
and
wrap
these
functions
in
something
it's
sort
of
penalty
memory
for
us,
so
we
don't
have
to
the
developer,
doesn't
have
to
think
in
terms
of
pointers.
You
know
number
of
bytes.
E
It
would
just
sort
of
figure
out
the
length
of
certain
types
automatically
and
I
guess
what
I'm
getting
at
here
is
I
would
like
contracts
written
in
assembly
script,
to
look
and
feel
a
bit
more
like
fiber
or
solidity
than
that
wasa,
and
so
we're
kind
of
in
this
weird
in-between
place
right
now
yeah.
So
this
should
look
familiar
if
you
saw
the
prompt
that
Casey
shared
a
moment
ago
and
Alex
shared.
E
E
E
We've
noticed
that
the
assembly
script
team,
which
is
really
small,
are
also
sort
of
very,
very
responsive
and
very
friendly
and,
like
we
had
this
issue,
which
Casey
also
mentioned
a
moment
ago
that
that
by
default,
these
imports
are
attached,
this
namespace
called
env
and
there
was
no
way
to
sort
of
fix
that
the
tool
chain.
So
what
I've
been
doing?
E
Is
this
really
obnoxious
manual
process
where
I
compile
the
assembly
script
to
blossom
and
then
I
convert
the
Oise
into
lost
that
I
go
in
for
the
text,
editor
and
change,
end
to
aetherium,
etc,
etc.
So,
within
literally
8
hours
or
10
hours
of
sort
of
us
having
a
kid
hub
issue
open
about
this,
the
assembly
script
team
jumped
in
and
added
a
feature
and
did
an
uber.
They
cut
a
new
release
of
assembly
script
that
now
this
is
no
longer
an
issue.
E
It's
actually
not
the
latest
code,
so
yeah
I'll,
just
I'll
pass
the
mic
back,
but
just
just
wanted
to
add
I'm
personally,
very,
very
excited
about
it.
That
blue
script
I
think
that
it's
a
it's
gonna
be
a
really
awesome
tool,
change
for
all
sorts
of
contract
development,
I'm,
even
thinking
about
doing
some
of
the
pre
compiles
and
stuff
in
the
assembly
script
so
excited
to
keep
people
in
the
loop
and
share
more
updates
about
that
soon.
A
A
Okay,
we
can
show
it
later
after
the
break,
so
we
should
okay
one
one
thing,
though,
so
anybody
who
wants
to
take
part
of
this
challenge
in
whatever
language,
even
if
you
want
to
write
it
in
rust,
again
or
assembly
script,
you're
welcome
to
do
it.
This
is
a
bitly.
Is
there
tweetable,
okay,
ki
j,
QA
d
well
or
you
go
to
gist,
and
my
username
you're
gonna
find
this
so
yeah.
Please
try
to
do
that
and
now
I
think
everybody's
still
like
a
week
right,
because
we
can't
go
to
an
actual
client
implementation.
A
E
E
A
F
F
Communicates
through
the
EVM
C
API,
unlike
a
traditional
EVM
implementation,
which
would
instead
communicate
through
direct
library
calls
so
here's
job
is
essentially
to
validate
and
execute
website
lis
contracts
as
well.
Well,
it
does
this
using
the
binary
interpreter
at
the
moment,
but
that
can
easily
be
changed
with
the
aforementioned
abstraction
layer
and
the
other
function
it
has
is
to
expose
the
host
function,
interface
to
the
executing
wasnít
module
now
so.
C
F
Assembly
module
has
the
ability
to
import
and
export
functions
and
global
data,
and
so
in
place
of
high-level
instructions
in
the
EVM.
We
use
a
set
of
standardized
imported
functions
that
allow
the
executing
Lawson
module
to
access
the
functionality
of
the
client,
and
so
here
we'll
go
into
a
more
in-depth
description
of
what
the
Tyrian
close
hub
function
interfaces.
F
So
it
stands
for
the
etherium
environment
interface
so
that
we're
currently
working
on
a
revamp
of
what
that
actually
means
at
the
moment.
So,
as
I
said
earlier,
it
allows
that
yozma
contract
to
access
client
functionality
like
state
querying
and
data
copying
and
calls
in
the
form
of
a
clearly
defined
API,
that's
exposed
to
every
D
was
no
contract.
F
So
in
one
we
would
have
this
giant
problem
of
mixing
abstraction
layers
that
would
result
in
performance
problems
and
generally
port
design,
and
so
it
consists
of
two
components.
The
main
one
is
the
host
functions
that,
as
I
said,
provides
the
state
querying
and
other
functionality
to
the
e
azam
contract,
and
then
we
also
have
a
set
of
debugging
functions
that
are
used
in
the
testing
context.
F
So
Pera
recently
has
been
upgraded
to
have
a
vm
abstraction
layer
which
allows
us
to
explore
the
prospect
of
using
different
washing
engines
to
execute
awasum
contracts.
So
at
the
moment
here
is
the
binary
and
interpreter
which
is
essentially
a
toolkit
for
wasn't.
That
has
a
couple
functions,
including
compiling
washstands,
interpreting,
Wazza
bytecode.
F
F
Wasel
mentions
will
probably
be
rabbit
and
wobbly
which
are
currently
a
work
in
progress,
so
why
that
is
another
C++
interpreter,
and
it's
a
it's
a
good
alternative,
and
it
also
gives
us
the
opportunity
of
differential
fuzzing.
So
we
can
test
for
discrepancies
between
the
behavior
of
different
execution
engines.
Now,
the
more
interesting
one
is
of
welcome,
which
is
a
standalone
LLVM
based
JIT
compiler,
and
obviously
that
would
provide
to
us
some
major
performance
benefits
that
allow
us
to
take
full
advantage
of
webassembly.
F
But
there's
also
a
couple
concerns
about
vulnerabilities
and
jiff
that
could
cost
them
denial
of
service
attacks
Network.
So
to
test
these
and
compare
their
performance.
We're
also
working
on
a
benchmarking
module
for
Hira
that
allow
us
to
get
better
data
on
which
was
and
that
execution
engines
work
best
and
also
potentially
for
what
types
of
bytecode
and
so
now
I'll
pass
it
off
to
deal.
F
J
So
we
have
this
pre-existing
VM
existing
and
go.
That's
called
the
wagon,
it's
an
independent
DM,
so
it's
been
developed
by
three
main
developers,
I
think
one
of
them
works
concerned
and
one
of
them
works
kakugo
and
their
goal
was
indeed
to
get
who
contracts
to
compile
code,
to
compile,
to
weather
and
then
execute
it
over
to
machine.
So
that
has
caused
some
problems
because
yeah
they
were
not
interested
in
extra
features.
J
J
Have
a
debugger
so
I
have
a
PR
that
I'm
going
to
release
probably
next
week,
so
I
expect
some
some
infighting
again,
but
this
being
said
I'm
trolling
a
bit,
but
at
the
same
time
the
advantage
of
Go
is
that
you
can
easily
put
take
a
different
project
and
integrate
into
your
tree.
So
when
it
came
to
to
interface
with
that,
that
was
actually
pretty
easy.
J
So
the
Terr
state
is
I,
have
an
initial
PR.
If
you
want
to
go
and
get
some
inspiration,
I
can
remember
looking
into
porting
that,
like
reporting,
it
wasn't
to
bring
him
to.
He
wasn't
I
have
an
example
in
go
and
at
the
moment
we
support
de
ID,
and
the
next
step
is
of
course,
to
optimize.
I
have
talked
about.
This
is
a
bit
but
yes
like.
J
So
the
lessons
I've
had
that
I
want
to
share
it's
basically
that
people,
especially
Ingo,
will
try
to
impose
the
language
philosophy
on
the
lesson.
So
go,
as
you
might
know,
is
extremely
opinionated.
Let's
say
so.
Everything
has
to
be
told
a
week
ago,
once
I
want
you
to
do
it
and,
for
example,
in
all
the
negotiations,
I
had
people
there's
an
interface
whose
functions
need
to
access
the
VM.
J
So
yes,
people
wanted
to
go
with
the
garbage-collected
language,
so
you
have
this
next
function
called
make.
You
can't
make
and
you
get
your
memory
and
you
don't
think
about
other
nation
and
all
those
things.
So
those
people
wanted
to
have
the
same
thing
from
whose
functions
being
able
to
call
to
go,
make
and
be
able
to
allocate
memory
insight
insight.
J
There
was
a
memory
which,
of
course,
meant
like
you
had
to
rewrite
the
garbage
collector,
because
there's
the
one
into
wasn't:
go
runtime,
there's
the
one
in
Coe
itself
and
then
there
would
be
a
third
one.
So
that's
a
bit
overkill,
so
there's
a
bit
of
a
debate
at
the
moment
and
so
yeah.
That
would
be
my
first
warning:
make
sure
that
what
you
bring
when
you
implement
was
them
to
your
own
language.
Make
sure
that
you
don't
bring
too
like
too
many
too
many
baggage
with
it.
J
What
I
found
was
reflection,
polymorphism
really
helped
I
mean
yes.
So,
for
example,
at
the
moment
we
have
three
potential
VMs
to
integrate
it
together.
There's
the
wagon
there's
the
e
BMC
and
there's
there's
the
other
Python,
more
of
which
you
will
hear
about
what
you
will
hear
later,
but
yeah
those
things
mean
like
hacking.
A
lot
so
thanks,
God
go
has
some
fairly
nice.
J
When
you
don't
work,
what
are
you
not
diem
already
has
all
the
real
issues
so
for
you,
so
just
make
sure
you
understand
before
you
get
started,
and
the
last
thing
like
the
last
warning
is
the
calls
calling
all
the
contracts
is
that
actually
be
tricky
at
least
the
way
it's
implemented.
Currently
why
that
is
extremely
inefficient.
So
that's
what
I
need
to
work
on
that
next,
it's
basically
you
have
a
VM.
J
J
I
J
K
It's
not
this
question
about
the
Wagner
wagon.
It
is
a
general
question
of
it.
It
wasn't
it's
something
that
occurred
to
me
when,
so,
if
I'm
writing
the
contract
or
something
else
in
C++
or
a
trust
or
even
and
I
can
go
there,
there
are
standard
libraries
right,
for
example,
everybody,
not
nobody.
These
days
writes
the
hash
marks
anymore.
They
just
reach
down
at
libraries
or
erase
so
and
as
I
understand
like
how
does
the?
How
do
they
look
like
in
a
basa?
K
We
look
like
a
mapping
where
you
can
just
specify
the
address,
and
you
get
unfortunately
led
to
some
of
the
some
of
the
unwanted
behavior,
for
example,
that
people
treat
the
contract
storage
as
if
there
was
some
sort
of
hash
map
and
it's
why.
For
example,
the
arrays
are
more
complex
than
mappings
in
in
solidity,
Viper
and
so
I
would,
in
hindsight,
I
would
say
that
it
should.
The
contract
storage
should
have
been
implemented
as
a
memory.
K
It's
like
a
contiguous
storage
would
be,
and
this
is
what
way
you
would
actually
be
able
to
use
standard
light
days
and
stuff
like
this.
So
maybe
before
you
solidify
the
API,
maybe
there's
a
chance
to
to
change
this
architecture
in
the
in
exterior
and
not
simply
follow
what
IBM
does,
because
it
might
not
do
things
very
well.
J
J
So
the
first
point
is
yes,
of
course
you
can
use
the
library,
so
it's
basically
just
outputting
to
different
binary
format.
So
you
have,
if
you
just
link
everything
statically
you
can.
You
can
get
most
of
your
functions,
namely,
for
example,
to
go.
Runtime
I.
Think
Alice
was
mentioning
before
that.
If
you
try
to
compile
small
concerts
and
go,
they
are
absolutely
huge
and
that's
because
the
whole
runtime
all
the
libraries
like
go
techs
to
grab
everything
it
makes
fat
binaries.
So
that's
why
you
also
get
fat
contracts
and
you
yeah.
J
F
F
J
A
There
probably
will
spark
reasons
to
optimize
your
compiler
or
your
code
to
certain
ways,
so
you
may
want
to
have
like
a
hashmap
implementation,
which
is
gas
optimized
and
second
today
there
are
a
couple
of
proposals
to,
and
this
host
functions
to
have,
a
couple
of
basic
things
exposed
which
can
be
use
by
the
contracts
and-
and
it's
also
possible
to
expose
like
libraries
if
I
firmly
with
like
have
solidity.
Libraries
work
still
not
that
way
in
a
better
way.
A
You
could,
basically,
you
could
withdraw
some
dynamic
link
with
other
wasn't
contracts,
so
there
could
be
standard
libraries
based
on
the
chain
and
you
wouldn't
need
to
compile
those
things
into
your
contract
and
I
guess.
The
second
question
was
more
related
to
this
table.
Nacelle
API.
So,
where
we
stand
right
now,
is
we
have
this
table
API?
A
To
start
with,
and
we
have
like
two
clients
fully
working,
so
it's
like
a
perfect
time
to
actually
have
a
discussion
and
think
about
how
you
would
like
to
change
the
API
and
how
you
would
like
to
change
aetherium.
So
that's
where
we
would
like
to
have
a
lot
of
discussion
with
the
research
team,
how
this
could
be
used
for
sharding
or
even
if
it
would
like
to
introduce
in
the
main
chain.
A
B
Coming
back
that
specific
comment
about
more
and
more
things
going
into
was
some
sort
of
libraries.
How
does
that
affect
the
trust
model?
I
mean
suddenly,
there's
contracting
live
on
chain
right,
but
if
we
start
dynamically
linking
in
stuff
from
LA
some
implementations
more
and
more
goes
into
there.
How
does
that
affect
know?
What
you're
running
yes,.
A
A
Just
big
blob
of
imports
and
in
was
on
imports,
have
a
namespace
which
is
the
env
here
and
have
the
function
name
and
by
default
all
the
compilers
use
this
env
as
a
default
namespace.
So
whenever
you
import
something,
it's
gonna
use
this
namespace.
Whenever
you
export
something
it's
gonna
use
this
namespace
some
compilers
have
like
native
support
to
have
like
an
annotation
for
the
namespace,
so
there's
the
assembly
script.
A
Compiler
has
a
way
to
do
that
right
now
and
if
the
internet
would
work,
I
could
show
it
rust
has
a
plan
to
support
it,
but
it's
not
in
the
language
yet
and
there's
an
attribute
in
C++
too
to
support
it,
but
I
don't
think
it's
supported
by
CNN.
Yet,
and
the
reason
I
mentioned
this
dynamic
linking
what
the
proposals
means
that,
instead
of
like
DTM
namespace,
there
could
be
a
contract
atmosphere
and
that
status
below
the
decode
from
and
that
code
could.
C
A
And
if
that
block
is
deployed
on
the
chain
at
a
specific
address,
we
could
import
that
method
from
that
specific
address.
So
that's
one
of
the
ways
to
do
dynamic
linking
now
the
problem
here
is:
yes,
if
you
like
self-destruct
the
contract
somehow
or
somebody
changes
that
contract,
but
I
think
this
is
kind
of
at
least
a
poem
entitled
of
scope
of
he
was
to
make
a
decision
on
that.
You
know
definitely
government's
who
governs
to
get
those
contracts,
you're,
gonna
use,
but
I
might
be
found
safe.
A
B
Bit
well
like,
like
the
real
question,
is
here
how
much
how
much
weight
to
it
on
the
chain?
How
much
of
the
code
goes
into
the
chain?
How
much
goes
into
the
VM
support
functions
that
are
supposedly
generic,
most
implementations
say,
gets
our
passion
whatever
it
might
be
right
there,
ostensibly,
you
could.
A
We
actually
have
decided
notion
system
contracts
so
that
pecan
pies
would
fall
under
system
contracts
and
what
we
could
do
is
provide
this
single
was
an
implementation
after
pecan
pies
and
a
single
like
library,
implementation,
which
would
then
be
project.
The
state
understands
the
code.
Hash
could
be
there,
but
it
doesn't
need
to
be
deployed
on
the
extra
state
by
the
clients.
Each
of
the
clients
would
have
to
have
it,
so
it
could
be
done
that
way
or
you
could
choose
to
do
it
in
the
actual
state.
A
G
J
G
C
G
Took
me,
but
it's
it's
nice
to
have
sort
of
a
translation
from
the
spec
to
Python,
so
we
we
own
it.
We
control
it.
We
can
do
whatever
we
want
with
it.
We
can
test
new
features
to
expand
the
language,
to
contract
it
to
suit
our
needs
and
we're
talking
with
high
high
EVM
people.
They
might
be
interested
in
using
a
full
native
Python
tool
chain
and
they
would
use
a
high
webassembly
as
their
execution
engine.
Their
concerns
include
tracing
very
important
to
be
able
to
trace
things.
G
I
also
found
out
that
the
people
at
true--but
might
be
interested
in
tracing
as
well
and
outputting
the
state
at
each
step,
so
right
now,
I'm
working
on
tracing
things
and
logging,
for
example,
you
want
to
debug
your
your
code
that
you
executed
there's
not
good
tool.
There
are
no
good
tool
chains
to
debug
your
your
webassembly
code
that
I
know
of,
and
it
would
be
nice
if
we
can
stop
through.
You
know
app
code
to
app
code
and
change,
see
how
the
staff
changes
to
how
the
memory
changes
these
kinds
of
things.
G
So
this
is
I'm
going
work
right
now.
For
me-
and
maybe
I'll
mention
it's
AI
is
still
sort
of-
there
are
still
some
typos
and
things
I
submitted.
Some
changes
to
this
150
page
stuck
document
I
have
more
changes
coming
because
there
are
some
small
errors.
Nothing
major
and
something
very
interesting.
I
think
we're
gonna
have
a
break.
I
guess
will
open
for
questions
before
break,
but
after
break
before
before
I
open
to
questions,
there's
something
interesting
about
implementing
things
and
Pavel
will
talk
about
some
sort
of
when
you're.
G
E
L
G
G
Was
nothing
written
about
direct
translation
it?
The
goal
was
to
implement
it
and
pass
some
spec
tests.
I'm,
currently
passing
all
spec
tests
that
are
relevant
to
us.
I'm
still
refactoring
some
things,
but
the
things
that
are
relevant
to
us
everything
all
the
spec
test.
Everything
is
done,
ready
to
be
used.
It's
not
aesthetically.
Some
things
need
to
be
sort
of
refactor
in
terms
of
aesthetics
and
also
to
be
more
usable
right.
Now,
it's
a
4,000
line
monolith.
What
I
wrote
did
I
answer
your
question.
G
Ok,
very
dirty
yeah,
something
very
important
now
so
I'm
interpreting,
so
there's
like
interpreter
that's
being
interpreted
so
I'm
interpreting,
blob
assembly
and
Python
is
being
interpreted
so
there's
some
sort
of
archaeological.
You
know
layers
of
interpreting
that
are
going
on,
so
it's
slow,
it's
not!
Maybe
it
won't
be
used
in
production,
I'd
slip,
its
I
compiled
some
Fibonacci
code
to
see
which
is
like
milliseconds,
and
this
took
maybe
seconds
to
execute,
but
so
there's
a
big
push,
and
this
is
a
theme
of
what
we're
thinking
about
is.
G
G
I've
made
some
bad
design
decisions
I
think
it's
a
good
idea
to
conform
to
the
spec.
It's
written!
It's
a
lot
of
structure,
it's
a
lot
of.
They
do
things
for
a
reason
and
you're
implementing
it.
You
say
why
are
they
doing
this
I'll?
Just,
do
it
my
way
and
then
20
or
40
pages
later
in
the
spec?
Aha,
that's
why
they
did
it
this
way.
So
now,
I
have
to
go
back
and
refactor
everything,
and
this
happened
several
times
to
me.
E
G
G
So
there's
these
kinds
of
thoughts,
but
I
think
the
Tracy
would
happen
at
the
granularity
of
webassembly
opcodes
and
webassembly
is
staff
based.
So
we
would,
you
know,
print
out,
perhaps
the
stack
or
print
out
chunks
of
the
memory,
maybe
there's
some
control
structure
that
we're
in
right
now
are
some
nesting
of
functions
that
we're
in
right.
Now.
That
would
be
relevant.
Of
course,
true
bits,
I'd
be
different
from
pie.
Uvm's
demands
so
it'd
be
nice
to
have
something
that's
flexible
and
generic
enough.
So
you
can
set
some
parameters
exactly
what
you
like.
There's.
E
G
Yes,
I,
yes,
I
think
that
this
was
a
good
tool
for
studying
and
sort
of
Cola
typing.
Yes
at
first,
maybe
might
be
usable,
I
main
and
the
whatever
live.
You
know
a
full
note,
but
eventually
I
think
it's
not
going
to
be
able
to
keep
up
and
pre-compiled
as
if
we're
talking
about
you,
know,
milliseconds
or
microseconds
versus
full
seconds
or
tens
of
seconds.
It's
not
going
to
be
able
to
keep
up.
So
yes
for
research,
there's
another.
A
G
G
G
So
in
the
spec
document
they
define
something
called
standard
embedding,
which
is
a
list
of
maybe
30
functions
that
if
you,
if
you
put,
if
you
provide
the
user
with
these
functions,
they
can
do
whatever
they
want.
They
don't
have
to
go
into.
You
know
all
of
these,
these
other
the
rest
of
the
inspector,
so
I'm,
actually
using
among
these
30
functions,
are
in
its
store
the
code
module
assam
that
everything
you
see
you
asking
that
get
exports.
G
So
if
you,
if
you
look
at
chapter
in
the
it's
in
the
appendix
chapter,
7.1
of
the
spec-
and
you
read
through
those
functions,
you
can,
but
that's
precisely
what
I
did
here
so
I
have
a
func
module
called
Fibonacci
that
Lezama
and
I
go
through
this
sort
of
stuff.
It's
a
little
bit
complicated
but
I'm,
just
following
I'm,
not
doing
anything
controversial
I'm,
just
following
respect
I,
maybe
I
can
sort
of
wrap
this
up
into
my
own
function.
G
I
I
G
Go
with
pipe
hi
yeah,
perhaps,
and
there
might
be
some
JIT
things
so
yes,
I
can
play
around
I.
Haven't
done
this
yet
I've
been
more
interested
in
getting
all
the
spec
tests
passing
but
yeah
I.
Think
yes,
very
good.
Point
I
definitely
want
to
study
the
whole
Python
environment
and
see
if
there's
any
cool
tools
I
can
use
with
us.
H
I
I
I
I
I
I
So
PMC
started
as
by
using
C
language
to
actually
specify
the
API
for
that.
So
previously
that
was
when
the
CC
letter
came
from,
but
we
is
the
process
of
dynamic
everything
we
also
renamed
at
a
bit.
So
now
it's
officially
called
aterial
client,
vm,
connector
api,
but
still
the
languages
is
the
way
of
defining
what
actually
functions.
Both
sides
have
to.
I
So
why
why
see
because
like
C,
is
probably
the
last
favorite
language
on
this
in
the
throw?
And
why
did
you
use
C
for
that?
So
mostly
because
it
happens
that
most
of
languages
have
some
way
of
at
least
importing
C
libraries,
because
they
want
to
communicate
with
the
operating
system?
They
want
existing
implementations
that
exists
for
years
and
don't
want
to
like
starting
with
implementing
all
of
the
libraries
in
new
languages
if
they
design.
I
What
else
can
I
say
about
design
of
you
can
see,
so
it
follows
polymorphic
approach,
which
is
it's
it's
tricky
to
spot
on
the
first
first
view,
because
it's
see
it
like
there's
no
classes
and
interfaces,
nothing
like
that,
but
you
can
design
a
class
class
diagram
of
all
the
of
the
concept
and
the
mostly
there
are
me
like
two
classes.
The
first
is
by
the
client
or
the
host.
I
The
piece
of
sorts
of
actually
enables
the
VM
to
access
the
state,
and
the
second
class
is
is
the
VM
itself,
and
because
of
this
because
of
having
the
polymorphic
design,
you
can
also
try
to
compose
BMC
more
sophisticated
way,
for
example,
have
some
kind
of
proxy.
You
can
actually
inspect
code
and
then
decide
which
concrete
implementation
to
use.
In
this
particular
case.
I
All
of
that,
like
has
two
sides,
so
we
have
the
client
API
defined
the
finder
and
it
it
was
a
Bitcoin
descendants,
but
it
matches
so
it's.
It
was
designed
to
support
all
this
all
this
up
code
in
here
at
access
and
modified
that
you
must
a,
but
it
happens,
it's
quite
quite
direct,
quite
similar
to
the
e
I
design
from
he
wasn't
so
the
eyes.
I
C
I
I
So
all
of
that
can
be
can
be,
can
be
found
on
github.
With
this
link,
the
main
header
function
includes
all
the
function
on
all
the
other,
all
the
API
needed
with
the
documentation.
You
can
also
check
out
generated
equipment,
ation,
but
working
is
generated,
but
oxygen
weights.
It's
quite
crappy
website.
Out
of
that,
and
also
I
yeah
feel
invited
to
the
detail.
Chart
okay,.
I
Quick
round
of
C
equals
what
actually,
how
do
we
use
it
and
what
where
we
can
put
it
right
on
so
we
have
C++
yet
that
recently
has
been
officially
renamed
to
pala
and
it
ships
with
plus
plus
interpreter,
and
also
we
can
use
EVM
jet
to
execute.
If
you
have
contracts
event,
it
still
supports
all
the
changes
up
to
design
tune,
but
it's
not
I
think
is
not
properly
maintained,
so
it
passes
all
the
tests,
but
I
think
it's
not
production
already,
and
what
we
added
with
the
housing
project
is
it's.
I
I
When,
when
when
like
the
go
to
go,
go
sub
product
is
finished,
I
plan
to
to
use
Python
to
actually
add
Python
bindings
for
I
had
a
prototype
long
time
ago
it
was,
it
was
as
good
as
high
up
was
called
back
then
and
was
which
was
able
to
reach
the
main
it
up
to
the
tower
hard
fork
block
when
it's
I
think
it's
stacked,
but
I
don't
believe.
It's
BN
reason
for
that,
and
maybe
if
there
is
more
interesting
in
this
product
without
no
TS
bindings
and
travel
findings.
A
I
Like
grant
I
my
sister
there's
a
tool
called
C
code
that
actually
generates
code
that
will
like
will
help
the
calls
to
the
cross
tech,
Go,
Go,
Lord
and
seaward
boundary
when
you
have
fraction
calls,
and
definitely
there's
nothing
wrong
with
that
it
should.
It
should
also
help
you
debugging
issue
with
that
with
up
with
some
random
inspections,
but
yet
it
can
happen.
We
have
some
very
interest:
intense
music
OPM,
especially
with
running
state
tests.
I
B
I
B
I
Doesn't
have
to
be
any
performance
criteria,
I
mean
we
would
have
it
wasn't
set
up
when
you
just
select
the
VM
based
on
the
code.
You
want
to
execute,
so
you
can
support
EVM
one
byte
code
and
it
was
a
contract
on
the
same
train.
So
just
so.
Actually
in
this
case
it
was
a
bit
differently,
so
mostly
there's
like
in
the
chain
that
here
is
the
first
one
and
it
can
answer
with
with
the
rejection
status
code.
I
If
the
hearer
discovers
that
byte
codes
actually
being
one
byte
code,
and
then
you
can
just
use
the
other
VM
to
execute
that.
But
that's
that's
what
your
would
also
like
to
have
in
case
objects
solutions.
So
it
might
be
not
worth
it
to
get
all
the
code.
You
can
have
put
some
like
strategy
pattern
on
top
of
that
and
decide
if
you
want
to
get
the
code
a
lot
based
on
some
some
external
input.
I
C
A
A
It
wasn't
clear
what
is
needed
in
a
language
to
actually
support
it
wasn't
so
there
are
two
things
usually
in
any
kind
of
language.
Well,
three
things.
First
of
all,
you
need
a
language
which
can
be
compared
to
water
and
in
any
such
language,
they're
going
to
be
able
to
import
external
symbols,
so
these
are
like
the
demanded
ste
ii
was
in
vm
would
expose
to
the
contracts.
So
this
example
here
is
the
rust
framework.
A
You
probably
would
want
to
have
a
high
level
API,
so,
for
example,
this
one
and
I
would
consider
this
like
a
middle
level,
so
that
it
wraps
all
these
unsaved
C
style
functions
into
vectors
and
manages
memory,
but
you
probably
would
want
to
have
in
any
kind
of
language
in
even
higher
level
where
in,
for
example,
this
instance.
It
returns
the
current
address
of
the
contract
and
you
would
want
to
give
it
as
like
a
big
number
or
like
an
address
type.
A
So
these
are
the
things
which
need
to
be
done
in
every
single
language
which
want
to
target.
He
was
not.
You
will
need
to
have
a
way
to
access
their
low
level
functions
and
you
probably
will
need
to
have
a
framework
to
use
them
efficiently
and
easily.
They
don't
applicative
work,
and
we
have
mentioned
that.
We
have
like
three
of
these
frameworks.
A
We
have
one
for
us
at
this
clip
which
is
nearing
usability.
It's
gonna
be
like
super
high
level
and
the
second
one
is
rust.
As
you
can
see
here,
it's
not
fully
finished,
but
it's
not
too
much
left
to
finish
this
and
obviously
the
c1
has
received
less
resources
because
he
wants
to
write
contracts
and
see
I
hope.
This
was
useful
to
get
like
an
idea.
What
is
needed
to
make
a
language
to
support
it
wasn't,
but
it's
not
too
much
effort
to
do
that.
Any
questions
on
that
cool.
H
H
H
There's
the
advantage
that
you
can
you
get
the
language
support
so
in
write
contracts
and
languages
that
compile
to
a
Google
web
assembly,
but
that
and
other
ecosystem
and
tooling
benefits,
but
generically
speaking
the
main
ecosystem
and
join
benefit
from
web
assembly.
Is
the
ability
to
use
the
JIT
compilers
that
heart
exists
for
webassembly,
so
that
you
can
execute
contract
and.
C
C
H
The
so
one
benchmark
program
is
the
easy
pairing
precompile,
the
one
that
was
edited
byzantium,
the
rust
version
compiled
to
webassembly
running,
and
so
we
call
it
three
times
which
I
think
is
below
the
gas
limit.
So
you
could
do
it
in
one
block,
you
know
and
the
interpreter
it
takes
21
seconds
and
a
jet
engine.
You
know
why
boom
it
takes
100
milliseconds,
so
the
difference
is
between
compiled.
To
be
interpreted.
To
be
is
enormous,
so.
H
Freaking
pounds,
it's
called
a
fake
compile
because
it
executes
at
native
speed,
and
so
it
has
its
own.
You
know
much
lower
gas
cost
than
if
you
run
it
in
an
EVM.
So
when
these
features
like
doing
with
the
curve
functions,
they're
too
small
to
do
in
EVM.
So
in
order
to
be
practical,
we
have
three
compiles.
H
H
I
mean
in
some
cases
it's
just
lack
of
documentation,
nobody's
updated
the
EIP
with
the
test
cases
that
we
have,
but
even
if
you
do
do
that,
you'll
see
that
I
mean
there's
a
lot
of
potential
test
cases
that
that
can't
be
written
and
if
you're,
not.
Writing
that
you
have
potential
of
consensus,
vulnerabilities.
H
Whereas
if
the
pre
compiles
were
implemented
in
webassembly,
then
all
the
webassembly
test
case
is
a
very
exist
guarantee
that
you've
got
coverage
over
just
the
vm.
So
you
don't
need
to
generate
test
cases
to
cover
all
these
interfaces,
or
you
know
some
other
library
that
every
client
could
pull
in
a
different
library.
H
H
H
H
H
H
E
It's
like
I
think
it's
like
before,
so
maybe
you're
talking
about
the
ways
of
running
yeah,
the
different
engine
types
when
you
talk
about
exe
compilation,
just
to
be
very
clear.
That
means
taking
wasn't
by
code
and
ahead
of
time,
compiling
it
down
to
native
bytecode,
whatever
platform
the
client
is
running
on,
and
so
what
in
practical
terms
is
and
the
clients
would
ever
actually
do
and
if
they're
doing
what
they're
doing
that
with
contract
code
at
their
store
in
a
database
or
something
like
in
like
x86.
If
you're
running
on
x86.
H
H
H
F
H
H
H
We
were
optimistic
that
maybe
webassembly
jet
engines,
because
web
assembly
is
designed
to
be
validated
in
a
linear
pass,
and
so
all
the
documentation
say.
Well,
you
have
one
in
your
past
and
it's
really
fast
to
validate.
We
were
hoping
that
it
might
be
really
best
to
compile
as
well,
but-
and
we
didn't
know
until
a
month
or
two
ago
when
we
go
wrong
end
of
our
process
or
punch
tester
hooked
up
as
fuzzer
to
v8
and
found
some
pieces
of
code
that
are
really
slow
to
compile.
H
So
these
are
the
20
kilobyte
pieces
that
take
v8
two
seconds
to
compile,
and
so
you
can
imagine
if
there
were
multiple
calls
to
this
in
in
a
block.
Well,
gonna.
Take
that
many
before
that
two
seconds
per
call
that
that's
up
and
we're
not
really
sure
what
exactly
the
features
are
and,
in
the
end,
the
bike
mode
in
the
assembly
that
that
the
JIT
doesn't
like.
But
you
can
view
all
that
you
can
scroll
down.
You
can
kind
of
see
the
the
patter
is.
Definitely
nesting,
it's
a
lot
to
do
it.
H
H
You
win
the
war,
then
it
would
be
nice
if
we
could
use
and
also
show
JIT
ends
and
then
it'll
also
be
nice,
even
without
the
case,
because
it'd
be
easier
for
clients,
just
use,
BA
or
Firefox's
thing,
or
you
know,
LLVM
Wow,
so
Bob
was
the
one
that
were
using
for
planning
to
use,
was
with
CPP
aetherium
inherit
well
with
EB
MC.
So
any
plan
would
be
able
to
use
problem
which,
by
the
way
after
Guido,
found
these
bombs
for
v8.
H
He
said
what
should
I
pose
next
and
I
said:
it'll
do
fuzz
wah
boom,
because
we're
gonna
use
that
next
with
CPP
theorem-
and
he
said-
oh
hey,
I
found
a
bunch
of
crash
bugs
and
waffle
and
then
yes,
then,
was
able
to
find
the
slow-slow
of
inputs.
The
JIT
bombs
and
I
said.
Oh
well,
that's
interesting
because
gos
is
about
to
launch
the
main
that
they're
using
wild.
H
F
H
Idea
about
compiling
LLVM
to
blossom
and
then
inject
during
injecting
metering
in
that
wasum.
So
that
way
you
can
meter
the
compilation
stage,
so
the
slight
twist
on
that
is,
rather
than
caching
the
compiler
machine
code
and
then
running
you
know
and
then
having
clients
run
these
DFCS,
which
would
be
harder
than
just
using
out-of-the-box
off-the-shelf
kid.
H
H
H
H
K
H
H
D
Yeah
sure
what
I
mean
it's
still
more
control,
like
the
thing
with
the
with
its
using
a
bomb
sniffer,
is
like
you
know
you
slip
on
Dave,
it's
like
whitelisting
versus
blacklisting,
and
you
kind
of
run
out.
You
know
you
want
to
blacklist
everything
and
only
whitelist
the
things
and
like
I'm,
worried
about
a
bomb
sniffer,
basically
only
detecting
the
things.
We
know
right,
yeah.
H
D
E
D
B
H
H
That's
what
I'm
saying
it's?
Not
it's
not
like
JIT
or
a
ot,
you
know
or
kiddie
wasallam.
That's
gonna
be
a
boon
for
scalability.
You
know
it.
Doesn't
it
doesn't
make
every
block
run
a
lot
faster.
It
only
allows
you
to
allow
users
to
deploy
their
own
tree
cause.
It's
not
gonna.
You
know,
get
you
to
a
thousand
transactions
per
second,
whatever.
K
So
if
you
could
shift
at
the
trade-off
we'll
say
if
it
becomes
like
million
times
cheaper
to
do
aromatics,
the
Nexus
and
a
state,
then
you
can
actually
deploy
some
algorithms,
which
trade,
the
computation
for
the
state
access
a
bit
more
and,
as
you
said,
with
a
cryptographic
step
or
you
can
like
deploy
more
of
this
through
our
techniques
and
all
of
those
stuff.
So
you'll
be
able
to
do
more
of
that.
So
it's
actually
moving
still,
even
though
it
doesn't
address
the
current
bottleneck,
but
it
will
be
able
to
ship
the
traders.
The
point.
C
L
H
H
C
G
Uses
a
pad
AG
based
intermediate
representation,
and
these
loops
have
loops
in
the
deck
and
that's
why
it's
so
slow
because
because
the
intermediate
representation
there
are
maybe
some
linear
pass
jits.
That
only
do
one
one
pass
through
the
code
so
that
we
characterize
will
be
perfect.
But
in
this
case
v8
is
unusable
for
us
because
of
these
specific
cases,
but
yes,
I
think
we
would
have
to
look
at
the
source
code
in
what
kind
of
IR
they're
using
what
kind
of
techniques
they're
using.