►
From YouTube: .NET Design Reviews: BufferReader
Description
Today we're looking at BufferReader
A
B
And
it's
easy
to
like
write
logic
to
do
that
to
cross
the
segment's
incorrectly
and
it's
also
difficult
to
rated
efficiently
and
yet
still
correctly
so,
I
mean
those
two
things
together:
a
big
driver.
What
is
pushing
the
need
for
a
further
year
that
can
deal
with
all
that
and
hassle
for
you,
and
we
can
kind
of
share
the
logic.
B
C
B
B
B
B
B
So
if
you
don't
want
it
to
like
throw
a
span
together
for
you
across
the
segment
out
or
you
can
just
get
the
sequence
back
and
look
at
the
individual
bytes
yourself
or
put
it
together
yourself
or
whatever,
and
that's
another
issue,
I
call
out.
So
if
we
were
to
have
this,
you
can
have
a
for
discussion
about
that.
Exactly
what
the
shape
is.
We
have
two
eaters
and
like
in
an
adapter
reader,
or
do
we
throw
them
all
together
and
take
a
perfect,
have
some
confusion
on
the
API
surface
right?
B
So
it's
really
a
matter
of
performance
and
and
having
methods
that
make
no
sense
when
it
comes
to
a
spam
them
right,
because
you
can't
return
the
sequence
out
of
a
spammy.
Well,
you
can
return
something.
It
means
nothing.
I
mean
some
of
them,
but
so
maybe
I
can
provide
a
bit
more
background.
So
this
is.
There
are.
E
Kind
of
two
different
things
that
happen
in
the
past
that
prompted
us
to
design
this
type
one
was
there
was
actually
a
battery
there
in
pipelines
and
we
were
planning
to
ship
it
in
3.0
to
part
one.
But
we
ran
out
of
time.
So
we
have
actually
a
buffer
reader
that
ships
internally
in
Castro
same
internal
type.
E
E
So
you
pass
the
span
and
it
will
give
you
like
an
int
and
it
will
tell
you
how
many
characters
it
were
consumed
and
you
need
to
then
advance
the
span
and
kind
of
do
you
know
kind
of
in
a
loop
and
people
seem
to
this
character
and
give
me
a
float
or
something
like
that,
so
the
reader
basically
takes
credit
card
slicing.
Were
you
afraid,
so
so
one
of
the
comments
that
I
added
at
the
end
of
this
prr
is
that
I
have
two
jority.
Basically
as
staring
it
was
explaining.
E
His
reader
accepts
read
on
the
sequence
in
the
constructor,
but
the
first
step
back
to
the
read-only
sequence
and
get
the
next
one
and
it
keeps
but
majority
of
the
methods,
just
so
very
basically
operate
on
on
spam.
So
I
was
thinking
that
we
can
combine
the
types
and
the
only
difference
between
those
two
modes
of
the
reader
when
it's
initialized
with
a
read-only
sequence
or
a
span,
is
that
when
it
runs
out
of
data
in
the
span,
there's
like
am
I
in
this
mode.
Okay!
E
E
You
know
I,
agree
that,
like
there's,
no,
ideally
where
we
would
have
one
type,
but
there
is
a
cost
to
this
to
this,
and
you
can
talk
I've
written
out
in
some
detail
about
what
what
you
give
up
in
that
case-
and
you
know,
might
one
of
my
other
concern.
You
know
one
things
that
comes
to
that
is
that,
like
the
spam
stuff
will
use
slower
a
heavier
weight
so
and
I
talked
about
that
is
another
one
of
the
issues.
E
B
Start
getting
hit
with
performance
of
copy
eight.
Well,
that's
so
for
any
reader.
What
was
it
has
internal
indices?
You
cannot
pass
it
but
value
so
because
then
you're
gonna
lose
when
you're
reading
at
different
stock,
framing
gonna
lose
when
the
stock
three
pops,
so
you
already
buy
it.
Well,
if
you
wanna
care
about
that
that
the
the
position
of
the
thing
that's
passing
it
when
they
do
not
care
about
position
it
when
you
read
well,
one
thing
is
like
peaking
stuff
and
things
like
that.
B
E
Speaking
but
wait
like
if
you're,
using
a
lot
of
cases
that
one
of
the
ones
that
I
brought
out
really
like
the
API
surface
before
we
dig
into
this
one
in
a
big
way.
But
using
this
sort
of
thing
for
general,
for
example,
like
the
typical
way
you'd
be
doing
like
performance,
is
really
important
in
a
lot
of
those
cases.
And
what.
B
D
G
B
I'm,
not
sure
if
I
understand
why
there
would
be
overhead
for
reading
itself,
but
you
don't
need
to
check,
isn't
it
was
not
like
because
for
spam
you
just
need
you
just
have
a
snow
season.
That's
not
so
what?
If
I
return
a
sequence,
you
need
to
turn
on
its
wonders.
Are
you
reading
from?
But
so
you
have
to
you
have
to
have
some
logic
when
you
ran
out
of
span
and
then
in
one
case
you
just
go
to
the
next
one.
In
the
other
case,
you
error
so
like
during
the
reading.
E
E
E
B
Called
therefore
I
don't
think
the
issue
is
that
it's
restaurant
versus
not
resurrect.
You
basically
are
saying
it
would
be
cheaper
to
eat
the
span.
Then
no
I'm
saying
that,
like
the
expansion
of
the
types
like
the
reason
why
we
have
two
is
because
of
the
whole
restaurant
thing,
so
you
said
that
its
performance,
not
the
rest
chapters.
E
Other
one
right,
so
you
know
of
any
significance.
You
already
have
memory
and
all
these
other
things
you
know
I,
don't
think
it
was
like.
We
need
to
be
making
stuff,
for
you
know
arbitrary
things
beyond
that,
I
don't
expect
like
an
explosion
of
things.
The
the
we
know
will
be
a
refs
track
because
it
has
to
hold
up
to
the
span
right.
So
if
you
take
the
sequence,
you
get
the
span
now,
that's
your
current
span.
If
you
take
the
span
directly,
then
that's
your
current
money,
you've,
basically
not
sequence.
B
You
either
arrow
out,
or
you
ask
for
the
next
pair
right
and
then
maybe
you
have
to
do
some
copying,
in-between
or
whatever,
but
I
think
the
question
is
now:
if
that's
the
model,
then
they
would
have
a
single
time,
which
I
think
would
be
so
you're
saying.
Basically
we're
not
gonna
have
ten
we're
gonna
have
two
demos,
because
you
know
I
thought.
That's
the
argument
that
you
make
the
problem
is
that
it's
pyro,
so
now
you
have
some
tire
level
component
that
will
be.
D
Now
I
have
a
jsonparser
that
you
know
one
students
from
spans
from
this.
You
know
it's
like
there
would
be
an
adapter
that
was
my
suggestion.
Is
the
white
if
performance
really
didn't
matter,
you
use,
but
earlier,
if
performance
matters
and
it's
critical
and
move
really
you're.
In
that
scenario,
we're
talking
about
where
you're
inside
of,
like
I'm,
creating
a
reader
I'm
being
done
with
it
at
the
end
of
this
date
of
the
road
right
like
or
I,
have
this
input
stream
and
it's
always
a
pipeline
right.
D
You
use
the
specific
one
right
that
gets
you
the
high
performance
so
which
one
is
then
genetic,
one
doctor
he
didn't
buffer
you
when
it
was
it.
What
is
the
type?
What
do
you
mean
more
time?
It's
this
this
type
or
some
other
time
it
would
have
the
same.
I
talked
about
it
down
below
be
basically
the
thing.
That's
the
union
of
the
two.
So
like
the
things
that
return,
a
read-only
sequence.
E
I'm,
a
little
confused
as
to
what
you
were
saying
earlier.
Were
you
proposing
that
we
don't
need
a
reader
over
storm
because
we
could
go
through
the
parsers
directly?
No
I
was
saying
we
should
do
you
don't
need
a
reader
that
forwards
for
you
like
managers
index
and
everything
just
one
universe,
and
it
works
with
everything
if
you,
if
the
performance
penalty
is
too
high
for
you
drop
to
low
level,
maybe
ice
and
do
it
yourself
so
to.
B
Give
you
to
give
you
a
character's
and
wanted
you
know.
As
you
know,
hacen
and
I've
been
like
iterating
and
back
and
forth
with
changes
to
this
for
a
couple
months.
Now,
a
lot
of
what
happens
in
here
like
what
you're
doing
binary
reading
it's
very
it's
relatively
simple
right,
there's,
not
a
lot
of
actual
like
logic,
that's
actually
in
there
as
far
as
number
of
methods
right
or.
B
Introducing
just
the
call
to
go
get
next
segment
actually
has
a
very
significant
impact,
and
this
is
why
ever
that's
listed
out
near
the
bottom
and
it
goes
like
in
some
cases.
It
goes
up
to
like
eighty
percent
slower,
but
if
you
could
have
fun
you
do
it
once
right,
because
you
don't
have
much
more
segments
so
the
first
time
you
try
to
advance.
B
Having
a
method
where
he
talks
so
the
logic
to
like
we
have
this
trying
read
again:
we
haven't
looking
for
the
surface
area,
so
this
is
I,
really
think
we
should
get
into
that.
So
we
can.
We
can
have
a
better
discussion
about
this,
but
like
try
read
for
a
binary
entity
and
it
has
to
be
on
management
and
it
just
basically
blitz
individual
right,
he
uses
the
Marshall
stuff
to
do
it,
checks
the
size
or
did
you
do
we
actually
have
that
many
bytes
left
fine?
B
You
know
I'll
call
the
marshal
thing
and
slap
it
into
that.
Otherwise
it
returns
false
if
we
don't
have
enough
bytes.
In
the
other
case,
we
have
to
call
back
to
get
the
next
BAM
yes
or
we
go
to
a
slow
method.
Actually
we
don't
go
to
next
and
we
go
to
this
limit
that
that
aggregates
the
stuff
for
you.
E
J
B
B
Much
right
so
like
when
we
go
to
parsing
right,
you
know
I'm
calling
utf-8
parser,
so
much
logic
is
in
the
utf-8
parser.
This
other
stuff
gets
lost
in
the
noise
right.
The
fact
that
you
have
an
extra
method
called
to
go
and
fall
back
to
the
well
I.
Don't
have
a
contiguous
thing:
I
need
to
go
to
the
slow
path.
It's
basically
that
does.
Also
that
can
be
there
are.
There
is
a
way
to
resolve
that
we
can.
B
B
B
B
Very
easy
to
like
collapse
them
and
like
just
not
show
anything
else,
and
we
get
rid
of
all
those
other
things.
What
I
would
like
to
do
is
like
get
the
EBI
surface,
agreed-upon
get
some
harder
measurements,
it's
and
then
come
back
and
like
and
look
it
I
mean
I
gods.
I've
got
some
already,
but,
like
I
would
like
to
take
that
portion
of
the
argument
as
a
separate
discussion
to
say,
like
okay,
we've
implemented
them
separately
yeah.
This
is
what
end
together.
This
is
what
the
performance
differences.
M
B
Know
with
various
optimizations
to
preserve
inlining
and
whatnot,
and
usually
it
was
kind
of
like
a
you
know,
10
15
percent,
overhead
and
I
think
if
we
can
get
it
to
10
percent
10,
15
percent
overhead
I
think
it's
worth
sacrificing
a
bit
of
performance
to
have
the
single
time.
If
it's
80,
it
doesn't
make
sense
so
there,
so
it's
cross
and
I
can
give
out
the
hard
details
on
it
now.
The
other
thing
to
remember,
of
course,
too,
is
it's
not
ten
percent
over
doing
it
raw
it's
ten
percent.
B
To
the
like,
you
know,
I
would
be
interested
in
I
know
you
send
some
emails
about
measurements,
but
I
was
not
for
me.
It
was
not
easy
to
see
you
didn't
check
in
the
performance
test.
Alright,
so
I
can
see
what
the
performances
are
doing.
The
porns
tests
are
in
there
actually
I,
just
like
I
just
switch
I
I
added
a
separate
one
that
used.
So
that's
one
thing
and
second
about
there
like
what.
E
It
happened,
you
said
you
know
the
only
would
be
Maki
and
you
kind
of
like
that.
What
would
we
do
with
this?
What
we
do
here
with
this?
It
would
be
good
for
you
to
actually
say
like
if
we
had
to
have
a
single
type.
What
would
you
recommend
it?
Look
like
yeah
like
what
would
we
do
with
this
I
call
that
others
an
issues
this
thing
to
follow
up
on
so
like
we
definitely
should
then,
like.
You,
can
see
some
of
what
would
be
weird
here
and
then
like.
E
B
E
B
E
B
E
You
would
never
do
what
some
of
these
things
right,
because
it's
like
why
you
know
you
can
build
on
yourself
when
it
comes
to
like
allocation
stuff.
You'll,
see
like
that's
why
some
of
these
helper
methods
are
in
their
way
and
speaking
in
someone
and
so
forth,
they
renovations,
but
you
know
going
back
to
this
reader.
The
main
scenario
for
it
is
to
write
high-level
parsers.
So,
like
you
know,
we
are
writing
JSON.
I
B
One
type
would
let
them
basically
design
one
parser
that
parses
either
expand
or
read
only
sequence
or
every
smell.
You
know,
like
many
things,
I
think
the
value
would
be
I,
think
there's
a
thicker
value
eg,
which
is
my
proposal,
was
that
had
an
adapter
that
did
that.
Basically,
so
you
know
ideally
we'd
be
able
to
find
some
way
to
like
which
way
would
dr.
work,
because
a
doctor
now
there's
a
permanently
French
Atlas.
B
B
E
Two
and
be
basically
constructing
what
both
of
those
two
items
or
there
would
be
some
internal
jiggery
that
we've
been
doing,
that
you
wouldn
t
able
to
access
externally
and
wouldn't
have
the
sequence
where
they
did
stuff
on
it.
So
that's
not
adopted
it's
a
wrapper,
yeah.
Sorry,
I'm,
okay,
my
bad,
but
what
would
people
write
Purser's
against
the?
What
do
you,
if
you
want
to
support
both?
You
write
it
against
that
rapid
I
want
to
write
a
fast
parser?
E
B
Of
our
customers,
well
I'm,
I'm,
hesitant,
I,
think
to
say
majority,
particularly
maybe
so
now
but
I.
Think
as
we
continue
to
have
something
running
in
the
cloud.
I
think
these
things
matter
a
little
bit
as
much
as
composing
is
starting
the
two
line
types.
If
someone
who
wants
to
ride
already
performance
thing,
they
can
say,
I
was
bad.
I'll
go
to
the
sequence.
Pan
reader
I
have
a
severely.
E
H
E
Nor
really,
ultimately,
performant,
because
if
you
care
about
performance
so
much
that
you
are
not
willing
to
accept
this,
this
type
of
the
over
can
you
better
reduce
utf-8
parser.
It's
very
definitely
the
following
person
will
be:
what
is
the
performance
difference
for
the
performance
difference,
yeah
between
between,
like
having
this
unified
type
and
having
two
different
parts?
He
says
80%
in
sound
is
enough.
Yeah.
E
E
B
E
M
B
M
H
H
O
B
E
E
A
performance
mode
is,
it
could
rip
out
the
renew
that
was
appropriate
rate.
If
you
really
cared
like
suppose,
you're
starting
to
go
down
some
chain,
and
you
have
somebody
together,
read
something
that
passes
it
on
a
reader
and
it
gets
passed
to
you
and
you
like,
have
a
special
path
for
the
span
stuff,
because,
like
you're
doing
things
that
you
don't
really
measure.
B
Right
so
you're
doing
a
bunch
of
binary
crap
and
whatever
you
could
basically
rip
the
check
it
rip
out
the
span
reader.
They
can
go
to
your
next
helper
method.
Right
that
you
care
about.
If
we're
not
careful
doing,
those
sort
of
things
retroactively
would
be
really
hard
yeah,
so
yeah.
Well,
that's
that's.
B
There
I
find
that
very
scary,
because
basic
code
ends
up
happening
is
if
we
both
introduced
at
the
same
time
right
and
both
have
names
that
are
somewhat
what
you
would
be
looking
for
likely
like.
Basically,
people
will
make
arbitrary
decisions
until
they
actually
measure
their
stuff,
but
it's
we
end
up
with
a
world
where
some
API
stake
signals.
We
do
some
API
stakes
BAM,
you
know
you
just
have
this
composability
issue
but
which,
by
the
way
you
can
already
see
today
like
this,
is
like
we
have
streamer.
B
We
have
stream,
we
or
text
reader
right
and
some
stuff
that
parses
text
files
only
exposes
the
reader,
which
is
nobody's
sake.
If
the
only
thing
you
have
is
a
is
a
the
streamer,
its
instantiate,
the
other
guy
and
and
and
grab
that
the
other
way
around
is
also
bad,
because
if
you
only
experience
stream,
then
you
already
have
a
reader,
then
I
don't
have
an
easy
way
to
expose
it.
The
other
way
around
right,
and
so
people
already
have
to
deal
with
this
and
make
it
has
cost
problems,
and
this
is
just
too
tired.
B
B
B
To
write
a
non
allocating
leader
or
not
allocating
nurses,
you
have
to
use
the
read-only
sequence
pieces
right
right.
So
if
you
have
something
where
you
can't
use
those
that
look,
so
if
you're
going
to
use
it
right
as
it
stands
right
now
this
this
one
on
its
own
right.
The
answer
here
is
like:
if
you
want
to
make
sure
you
never
allocate
right,
you
don't
call
the
things
that
return.
D
You
recall
the
things
return,
the
winnowing
sequence.
You
decide
how
you're
going
to
like
put
those
things
together,
if
you
have
to
put
them
together
right,
so
whether
you're
getting
stuff
out
of
the
array
pool
whether
you're
you
know
iterating
through
that
yourself
and
splitting
it
up
in
some
other
way
into
a
small.
It
doesn't
matter
right.
You
are
in
control
of
the
allocation
right,
so
that's
something
we
would
have
to
address
is
that
we
would
have
to
hold
add
more
complexity
in
those
things
to
be
like
have
this
thing.
Allow
you
to
do
allocations.
D
D
B
B
So
if
you
have
to
keep
track
of
the
third
it
would
be,
you
have
to
do
it
a
ridiculously
slow
because
you
would
have
to
and
you'd
have
to
leave.
You
do
contain
the
original
one
you're
after
you
take
the
original
one
and
reindex
into
it
through
would
have
to
walk
back
through
to
get
you
the
read-only
sequence
back
out
again,
it's
especially
for
Jason
reader
time.
B
The
point
I
was
trying
to
make
is
it
would
be
useful
to
brainstorm
like
comes
of
the
allocation
problem
and
I
think
there
are
many
different
I
love
the
idea
with
single
reader,
but
I
also
buy
by
using
this
buffer
either
because
I
found
out
that
without
having
a
sequence
on
it,
I
just
I,
subject
and
I
said
to
you
know
poking
holes.
You
could
imagine
trimethylamine
like
there
are
many
different
things
that
we
should
explore.
E
F
J
E
E
H
H
B
E
B
H
B
Like
that's,
that's
why
I
think?
Fundamentally,
it's
not
like
a
pay-for-play
thing
for
a
parser
implementer,
because
there
has
to
be
to
divide
the
code
twice.
They
don't
for
the
people
that
don't
care
and
we're
going
down.
What
I'm
saying
that
people
don't
care
about
the
performance
but
again,
but
but
let's.
E
H
E
D
E
D
Second,
half
of
this
looking
at
the
API
and
I
think
it'll
help
clarify
because
it
without
knowing
what
these
api's
are
doing.
It's
a
little
abstract
to
imagine
because
again,
I'm
totally
on
board
with
like
ship
West
types
as
a
starting
point
for
things.
I
really
would
prefer
to
have
one
type
I'm
just
super
concerned
about
the
usability
thing,
both
from
like
the
API
surface
and.
B
D
With
them
and
for
a
usability
standpoint
right
and
then
people
that
wanted
to
use
it
for
span
would
never
use
it
because
they
wouldn't
just
it
would
just
not
meet
the
characteristics.
So
we
have
this
functionality
that
nobody
would
use
outside
of
like
having
to
write
conditions
in
their
code
to
say,
like
oh
well,
I
can't
use
the
read-only
sequence
stuff
or.
N
O
N
B
B
Well,
yeah,
that's
that's
a
now
location!
Well,
you
or,
or
you
provide
a
buffer
to
writing
together.
Asan
is
rating
Jason
par
set
up.
Well,
he
does
not
do
it
does
not
want
to
allocate
the
string
every
time
as
we
discussed,
you
return
a
string
or
the
caller
provides
a
buffer
or
adventure.
What
a
mystery!
Yes!
So
that's
so
now
you
let's
go
today!
B
Yes,
because
I'm
with
you,
I'm
thinking
that
we
can
design
api's
such
that
they
don't
allocate
event
in
the
case
of
string,
so
it
would
complicate
down
the
it
would
complicate
the
object
model,
because
now
you
have
to
kind
of
be
more
careful
when
you
pull
under
it
on
the
sequence
returning
readme
string
but
I,
think
it's
a
work
thing.
It
also
gets
into
this
whole
other
thing
we
were
seeing
as
well
every
because.
H
H
E
E
B
B
Only
staying
has
to
be
cache,
which
we
talked
about
this
in
order
to
get
any
reasonable
performance.
Right
obviously
makes
the
reader
itself
have
to
be
wrapped,
even
though
sequence
is
not
they,
and
you
know
in
being
fast
that
we
want
to
optimize
for
things
not
crossing
boundaries
so
like
whenever
you're,
not
crossing
a
boundary,
you
should
be
as
fast
as
possible.
Then
we
start
taking
hits
with
across
the
boundaries
right.
B
We
still
want
make
that
as
optimized
as
we
can
but
like
we
don't
want
to
take
a
hit
and
we
don't
cross
a
boundary
right
state
necessary
the
other
ones
that
there
has
to
be
zero
allocation
options
and
scroll
functionality
right.
So
you
you
need
to
be
able
to
write
code
in
and
have
it
understandable
in.
E
B
D
B
B
B
Have
the
functionality
right
yeah?
So
this
way
you
could
also
just
say:
if
we
ever
have
to
support
you
to
16,
we
can
just
add
members
to
this
narrator,
essentially
I,
suppose
it
there's
no
Jamaica's
right
now,
we'll
see
that
so
like
it
doesn't
block
there,
it
doesn't
block
shipping
the
leader,
it
blocks
your
thing:
you
have
16
functionality.
What
what
weapons,
if
I,
instantiate
a
sequence,
reader
of
rule
or
sequence
reader
event
you're
fine,
but
what
does
it
mean
to
do
that?
B
B
Like
the
the
functionality
that
is
specific
to
types
that
we're
understanding
here,
like
okay,
the
the
bite
during
whatever
else,
those
are
all
extension
methods:
okay,
yeah,
that
make
sense.
So
if
you
want
to
have
a
if
you
want
to
do
a
reader
of
it's
fine
like
okay,
I,
just
didn't
like
when
I
started,
looking
at
again
trying
to
reduce.
E
E
B
B
B
Like
the
current
sequence,
that
you're
in
so
is
there
a
way
to
rewind
without
doing
this
by
capturing
my
current
position
so
because,
basically
I
imagine
that
persons
could
do
the
following,
like
I'm
about
to
do
something
that
potentially
I
will
have
to
rewind,
so
I
store
position
and
then
the
rewind
takes
position,
and,
although
you
don't
have
to
stand,
you
can
just
imagine.
Okay
I'll
show
you
later,
but
the
tree
that
is
very
loud,
yeah,
yeah
yeah
so
coming
in
over
the
readers
large.
B
So
what
what
my
preliminary
looking
at
this
like
trying
to
reconstruct
from
a
position
is
just
as
expensive,
if
not
more
expensive
than
trying
to
play
copy
the
reader.
The
big
optimization
that
we
have
here
is
simply
that,
like
what
we
do
is
we
do
the
smarts
of
saying
look.
You
want
to
learn
your
mind
this
far,
okay
you're
in.
B
B
E
N
B
B
Than
copying,
what
do
you
mean?
Really,
when
you
read
only
sequence,
is
super
long
has
many
segments,
it
will
be
very,
very
expensive.
It
can
be
potentially
if
you're
going
to
go
through
a
bunch
of
yeah.
The
presumption
is,
is
it
like
if
you're
like,
if
you're
not
gonna,
be
in
the
current
span,
most
typically
I
actually
didn't
call
this
out,
I
should
have
I
probably
did
for.
B
E
B
Eyes,
rewind
is
not
something
you
have
to
do
very
often
it's
an
error,
state
type
of
scenario
that
you're
in
so
what
one
of
the
things
being
any
more
data?
Okay,
what
was
the
use
case
for
rent?
So
if
you
have
partial
data
and
you
try
to
read
something-
you
find
it's
incomplete,
I
already
advanced
the
leader
too
much
I
need
to
divide
that.
How
how
do
you
stick
new
or
it
only
sequence,
its
into
the
river?
It's
a
typical
parser
thinking.
So
first
it
goes.
B
E
B
B
E
B
No,
so
you
only
advance
by
when
you
reach
a
stable
point,
so
your
parser
is
parsing.
Parsing
well,
I,
successfully,
first
hole
method,
I,
don't
need
to
I,
know
I,
don't
need
to
rewind.
Then
you
advance
power,
so
you
know
advance
pipe
unless
you
in
a
stable
point
and
you
know
thence
depart,
but
what
you
need
to
backtrack,
that
you
saying
you
need
to
prepare
to
get
more
there
to.
Maybe
just
you
know
how
parsers
have
different
branches.
They
don't
know
yet
whether.
E
B
N
E
I
H
Not
have
it
be
modeled
in
the
other
one
about
like
this
whole
thing
about
having
a
whole
bunch
of
sequences
is
very
nice
or
why
not
just
allow
you
well
advance,
take
so
long.
Why
not
just
allow
passive
in
the
negative
argument
before
the
reason
I'm
just
kidding?
Oh
okay,
sorry!
So,
okay,
that's!
It's.
B
I
E
E
B
It
could
be
a
tow
there's
no
tradition
is
it
doesn't
have
to
be
public?
Well,
you
would
have
to
slice
it
to
get
this
of
yourself
if
I
can
get
more
light
yeah,
but
you
do
in
a
lot
of
cases
all
right
when
we
see
that
all
the
time
so
like
in
our
own
logic
that
we
get
it
right
for
all
these
extension
methods
and
things
that
you're
getting
the
unread
span,
because
you
want
to
deal
with
your
in
spam
yourself
didn't
really
complicated
IRC
on
them,
so
you
would
want
to
avoid.
I
B
I
B
Control
like
we
can
always
add,
api's
to
spam,
that
are
like
dangerous
lice.
We
can
do
that
like
we
can
make
it
so
that
we
don't
have
to
change
the
api's
here
just
because
we
perceive
performance
problems
elsewhere
and
then
shorter,
technically
I.
Don't
think
this
could
be
over
you're
having
an
edutainment
I.
B
It's
just
the
two
of
them
together,
seeing
a
bit
weird
if
I
were
to
get
rid
of
anything
I
would
say
current
span,
but
let
her
just
I
think
can
spend
heads
to
understand
what
can
spend
indexes
yeah.
Well,
you
would
imagine
you
wouldn't
have
that
either
or
if
you
were
yeah
yeah.
Why?
Why
do
you
care,
like
you've
all
you've.
B
F
B
O
B
That
you're,
in
a
sort
of
difference
with
this
one,
is
that
white
seeking
backwards
does
have
a
performance
issue
with
just
like
with
streams
I
or
or
they
gonna,
throw
if
they
don't
support
like
me
with
the
realign.
Well,
there's
the
nonce
eatable
streams,
but
I
don't
think
they
have
the
same
sort
of
performance.
I
B
Can
go
both
ways
on
it,
but,
like
I,
think
that
they
like
there's
there's
there
is
some
value
in
robbing
people
space
in
the
fact
that
they
are
they
weren't
that
there's
a
different
just
like
we
make
some.
We
don't
make
something
we
don't
want.
Properties
have
hidden
grab
on
how
much
performing
some
we're
changing
state
or
whatever.
There's
there's
a
by
having
separate
methods,
it
kind
of
lunch
people's
face
into
the
performance.
B
I,
don't
know
if
I
didn't
meet
the
dots
on
this
and
I
decided
and
rewind
I,
don't
know
if
I'd
necessarily
know
that
odd
realign
is
no
good,
like
there's
also
the
thing
if
you're
going
in
and
like
auditing
stuff,
you
go
back
and
you
look
for
all
the
remaining
stuff
and
you're.
Finding
negatives
is
not
so
easy,
it's
finding
all
the
rewinds
and
like
double-checking
to
make
sure
we
live
like
they're,
not
being
using
them.
G
B
G
B
Should
look
at
the
perf
on
it
to
see
because,
like
I
mean
with
pipelines
to
me
with
dreams,
but
personally,
if
we
get
more
feedback
on
it,
I
could
look
at
the
perf,
because
that
would
be
the
other
just
an
out.
So
this
advanced
just
like
the
most
perfect
critical
piece
in
the
entire
movie,
like
it's
calling
advanced,
happens
a
lot
right
and
sometimes
a
ton
that
you're
really
small
data.
That
really
shows
up
any
changes
we
make
to
advance.
B
Though
super
sensitive,
because
most
people
I
would
assume,
would
just
call
the
tryparse
method
and
then
the
thing
internally
advances
are
calling
advanced
but
advances
and
isn't
the
hot
path.
Now
as
an
implementation
of
duty.
All
of
these
other
methods,
you
know
he
doesn't
have
to
call
it
that
I
mean
you
can
have
its
private
version.
H
B
I
M
B
E
C
C
G
B
B
N
But
yet
you
imagine
that
you
know
invented
your
new
binary
format,
what
I'm
saying
right
and
there
isn't
even
now
just
add
a
namespace
with
extension
methods
that
read
your
whatever
format
that
you
know
so
once
what
one
looks
are
going.
There's
another
issue
not
to
consider
the
sign
up
here
and
I'm
trying
to
get
my
head
around
attention
later
for
a
broader
understanding
issue
at
some
level
as
we
go
from
our
Corp,
you
know
fast
stuff
at
some
level.
B
B
Methods
and
other
things
that
are
accomplishing
the
goals.
You
know
things
like
the
pipeline
stuff
that
is
going
to
allow
those
goals
to
be
met
by
the
user,
but
we
can't
have
visual
basic
users
be
unable
to
parse
faster
than
what
they're
doing
today,
because
we
used
in
the
English,
so
they
can
say,
I
managed,
constraint,
I
saw
and
maybe
around
is
completely
ignored
by
other
languages.
Correct,
yes,
but
would
this
work
if.
M
You
had
a
language,
it's
a
prototype
that
didn't
have
that
constraint
and
wouldn't
that
make
this
unusable
by
that
there
are
no
throw
when
validating
the
type
yeah.
You
would
get
that
I.
Don't
want
us
to
do
all
this
too
far.
I
do
want
it
to
kind
of
be.
In
the
back
of
folks
mind,
we
can
have
a
separate
like
the
people
that
care
sit
down
and
see.
What's.
A
D
D
H
D
E
I
I
To
the
high
level
point
I
think
you're
not
doing
really
knit
new
stuff
here
right.
What
we'll
be
doing
is
we
do
the
things
you
could
have
always
done
with
a
frame.
You
can
always
read
ins
and
UN's
and
daytime's
and
whatever
right,
but
so
we
just
make
the
10x
faster
or
100x,
whatever
the
factor
is,
and
in
order
for
us
to
do
that,
we
had
to
change
the
types
of
some
other
things
to
get
to
that
perf
right,
so
that
the
languages
can
still
do
these
things.
E
I
I
I
D
I
E
D
D
At
some
point,
I
would
think,
there's
some
middleware
that
it
gives
you
access
to
more
raw
data
structures,
in
which
case
every
person
would
still
be
able
to
compose
middleware,
but
they
may
not
be
able
to
participate
in
building
them
all
right
and
so
I
think
that's
one
of
those
things
where
you
can
probably
draw
a
line
and
say
yep,
some
things
aren't
accessible
to
be
dwell
oppress.
The
questions
do
we
believe.
I
E
D
Said
like
what
we
want
to
read
out
a
date
time
or
something
like
that
right,
you
know
we
need
this
many
by
in
binary
format.
We
need
this.
Many
bytes
we
can
just
stack
out
up
to
that.
Many
bytes,
pass
it
to
peak
and
peak
will
either
copy
into
it
if
it
has
to
like
aggregate
or
it
will
just
return
you
a
slice
for
out.
B
B
I
D
Course
is
that
you
haven't
moved
forward
and
you
have
to
rescan
the
entire
thing,
but
you
have
to
move
you'll
have
to
advance
later.
That
was
still
the
scam,
the
entire
thing,
maybe
yeah
so
like
here,
here's
the
like
when
we
peek,
so
this
thing
will
return
whatever
Deena's
laughs
so
like.
If
you
were
trying
to
read
out
a
date
time,
if
you
didn't
have
enough
bytes
you'd
get
back
a
spam.
D
That
was
too
small
they've
been
failing
right
because
we
can't
cast
to
to
that
because
we
don't
have
enough
bytes
left
right,
other
things
where
we
use
this.
We
look
to
see
if
we
use
it
internally
for
these.
A
lot
of
these
things
we
want
to
see
like
you
asked
for
this,
can
I
pull
this
together,
we'll
look
at
it
in
that
framework
or
you
get
it
out
yourself
and
you
make
a
decision
about.
This
is
the
whole
rewind
can
be
expensive
right,
but
peak
can
tell
you
in
his
particular
case
and.
B
Stuck
it
rewinding
in
that
particular
case.
Well,
other
things
when
you're
reading,
like
you
may
be
reading
to
see
like,
is
there
a
character
team
Lyford?
Is
it
a
crlf
at
this?
At
this
point
right,
you
can
peek,
let's
see
where
we're
the
greatest
in
here's
the
main
scenario:
I'm
writing
the
parser
for
a
language
and
I
want
to
check
whether
the
next
you
know,
identifier
is
for
I,
think
three
characters
and
compare
it
to
four
and
I
can
do
it
without
allocations
and
very
efficient.
So
the
in
we
have.
B
We
have
all
our
toppers
here.
The
deal
with,
hopefully,
the
most
common
cases
for
peeking
ahead,
like
a
new
destiny,
is
next
yeah
so
but
like
oh,
we
didn't
want
to
write
his
next
as
deep
and
competitive
yeah
yeah.
So
like
there's
and
it's
even
more
optimized
right
like
the
one
that's
here
doesn't
have
to
compose
it.
Look
if
you're
imposing.
H
B
B
I
believe
that
overload
of
peak
actually
leads
to
performance
problems
in
the
common
case,
because
for
someone
to
pass
in
a
scratch
buffer,
almost
certainly
they're
going
to
be
stack
now
looking
at
scratch
buffers-
and
it's
going
to
be
very
common
for
people
not
to
have
not
to
have
the
attribute
that
says,
don't
zero
and
it
locals,
which
means
that
the
compiler
is
going
to
have
to
pessimistically
zero
out
the
scratch
buffer
just
so
they
can
pass
it
in
to
peak
on
the
off
chance
that
they
happen
to
be
crossing
a
second.
So
there's
there's.
B
This
is
kind
of
like
one
of
those.
The
more
advanced
api's
that
are
on
this
and
there's
I
have
a
rather
detailed,
lengthy,
but
like
so
in
some
cases
you
may
want
to
be
pulling
it.
You
may
want
to
be
reusing
a
scratch
Bachman.
For
example,
like
you,
you
get
something
out
of
the
array
pool
or
you
know,
to
allocate
once
in
your
reader
that
you
have
your
scratch
thing
for
a
bucket
in
scratch.
B
So
there
this
one
has
already
quite
a
bit
of
XML
comments
on
it,
but
I've
no
clue
to
be
these
sorts
of
things
are
definitely
deserved
and
that's
but
there's
other
ways
around
yeah,
and
incidentally,
this
is
like
a
big
reason.
Why
I
think
these
ones
are
important.
It's
a
big
thing
like
well.
In
most
cases,
don't
want
to
have
to
mess
with
that.
E
B
I,
don't
know
that's
what
I'm
asking
you
Gareth.
Nothing
else
can
modify
this
pan
were
because
it's
tech
only
so
you
don't
really
need
a
copy,
your
own
I
I.
Don't
you
don't
need
a
cover?
Maybe
somebody
can
know
somebody
passed
me
above
I
see
and
it's
being
what
if
I
said,
okay
copy
the
next
painting
to
my
buffer,
what
I
found
advancing.
B
B
B
Of
the
things
we
found
in
iterating
with
the
JSON
we,
the
experiment
is
like
making
a
second
call
to
advance
or
not
advance
like
trying
to
be
able
to
like
being
able
to
aggregate
those
when
you
need
them
aggregating.
It
has
a
very
measurable
impact
on
your
person,
so
I,
don't
we
call
it
like
in?
We
have
this
concept
in
some
existing
API
said
we
call
it
usually
starts
with.
O
I
B
E
E
B
Rate
needs
to
be
able
to
return
true
or
false.
Okay.
So
then
you're
saying
in
the
if
this
boolean
is
true,
you're
saying
exception
would
be
faster.
Yes,
I
mean
we're
talking
about
performance
above
all
else
right.
Well,
so
the
performance
is.
If
I
don't
wants
to
basically
do
returns.
False
and
I
want
to
do
something
else
than
throw
an
exception
yeah.
Well,
then,
you
have
private
right.
Are
you
saying
the
channel
between
after
work
doesn't
do
wrapping
the
try
catch?
B
E
E
B
That
I
would
say
around
that
is
like.
Currently,
there
is
no
throwing
on
any
of
the
methods
that
is
not
like
bad
input
yeah.
So
this
would
be
the
very
first
one
that
it's
not
really
bad
input,
so
there
is
throwing,
if
you
like,
go
out
of
bounds
right
for
like
advancing
and
stuff
like
that,
there's
throwing
if
you
like,
pass
in
a
format
character
that
isn't
support
yeah
yeah,
it's
that
sort
of
thing
yeah,
but
you
can't
throw
from
any
of
these
other
ones
so,
but
does
that
make
sense
and
like
why?
B
This
is
convention,
go
crazy
when
you're
creating
that
buffer
you're
getting
copies
in
some
cases,
this
one
we've
never
copy
these.
Next
just
does
the
right
thing,
then
yeah,
it
looks
so
whenever
allocates
never
copies,
are
any
next
I've
called
this
out
down
below
you
know
or
like
from
a
performance.
B
B
G
C
I
B
B
If
you
try
to
figure
out,
why
not
like
I'm,
looking
through
the
source
and
advanced
last,
why
is
it
faster
to
put
it
inside
then
to
put
it
outside
of
the
method,
but
it
just
goes
advanced
inside
the
method
for
the
true
cases,
so
why
is
it
faster
to
to
put
it
into
the
sir?
What
members
read
description
and
argument
what
it
does
it
this
does
if
on
the
result
and
yeah,
because
it's
all
internal
to
disrupt
the
dinner
does
a
better
job
with
it.
B
Otherwise,
if
you
don't
get
this
but
I'm,
actually,
instead,
what
you're
proposing
then
you'll
have
to
it
advances
once
inside
and
then
you
have
to
know
it
doesn't
yeah
those
whoever
the
advance
in
is
next
method,
because
there
are
there
are
there?
Why?
Oh,
you
want
to
know,
like
logically
why
you
would
want
to
know.
E
B
E
E
Well,
it
starts
with
and
then
advanced
yeah
that
is
cleaner.
What
is
cleaner,
removing
the
advance
past
parameter
interesting
if
the
caller
wanted
you
to
advance
as
you're
saying
to
like
just
make
the
caller
call
advanced
it's
it's
measurably
worse,
but
only
in
the
current
chip
like
that's
something
we
can
change
in
the
job.
E
B
H
B
E
B
H
H
B
H
B
M
B
H
E
B
M
M
N
Statement
that
checks,
whether
I,
will
be
crossing
the
boundary
or
not,
and
then
either
allocate
or
copy
I
mean
either
just
get
the
spanner
or
cop,
like
I
was
doing
at
peak.
We
could
have
something
pass
in
a
scratch
buffer
and
stuff
like
that
or
some
callback
or
something
that
allocates
like
they
were
there.
One
of
the
thoughts
was
is
that
we
have
a.
D
B
B
I
have
to
repeat
the
well.
You
asked
us
early
for
a
caller
to
know
that's
how
yeah
so,
but
as
one
where
negation
thing
I
thought
well,
one
of
the
things
we
could
do
is
we
could
actually
have
you
pass
and
that
would
actually
do
like
because
right
now
we
just
arbitrarily
make
it
like.
If
you
want
it,
if
we
have
something
that
like
provides
that,
whether
it's
a
it's
a
thunk
or
whatever
there,
but
we
could
do
that,
there's
a
possibility.
What
do
we
do
what
you
said?
B
H
H
B
E
You
know
it's
on
the
table,
but
you
cannot
get
it
out
of
your
stack
and
now
it
has
all
the
disadvantages
of
the
spam
and
it
also
on
the
hip,
yeah
and
also
like
you
know.
This
is
kind
of
the
main
pattern
that
we
have
in
many
of
these
api's
is
that
Colleen
never
allocates
yeah,
and
this
is
an
API
that
not
only
call
he
allocates.
You
never
know
whether
they
did.
B
Or
not,
and
the
thing
they
are
carrying
is
not
useful
pass
just
and
anything
that
they
are
located
in,
but
again
with
the
Moodle
like
one
k4k
sort
of
boundary
thing
and
we're
talking
about
in
the
jet.
The
expectation
is
that,
like
very
rarely
will
you
allocate
and
when
you
don't
allocate.
This
is
very,
very
fast
right.
So,
if
you're
within
this
sequence,
because
it's
just
a
slice,
so
quick,
quick
question
on
try
we
to
so
say
that
I
call
try
Ritu
mama
and
that
will
by
default
and
go
past
the
comma.
It.
B
B
I
B
H
E
B
M
H
H
B
B
G
H
E
F
F
F
H
H
H
C
B
Advance
that
you
care
about
yes,
good,
because
it's
the
one
that's
actually
called
advance,
and
it
has
no
other
ones.
It
has
all
right
now.
Maybe
you
can't
have
overload
Smith
the
reason
that
I
can't
is
once
you
have,
like
sequence,
reader
of
long
or
sequence,
reader
of
any
yeah.
Now
your
skirt,
we
could-
or
we
could
call
it
advance
by.
F
H
B
Across
segments,
why?
Because
you
may
read,
like
you
think,
about
denial
service
right
yeah,
you
know
somebody
feeds
in
and
something
that
they
know
pork,
you,
because
you're
gonna
allocate
out
the
wazoo,
because
you
have
to
make
one
sorry
why?
Why
would
you
allocate?
Because
we
call
the
UTV
a
person
underneath
no.
D
K
K
M
K
K
B
So
we
can't
look
at.
We
did
hard
code
for
the
end
case
to
say,
plus
minus
ending
on
a
on
a
thing,
we'll
try
again
right,
but
like
some
arbitrary
place,
looking
for
E
and
stuff,
like
that,
it
started
to
get
really
complicated.
So
look!
Okay!
So
let
the
putters!
Well,
we
can
all
what
it
broke.
We
call
it.
It
call
what
we
call
try
cars
yeah
on
the
four
bytes
yeah.
If
it
returns
true
and
three
bytes,
we
know
that
it
consumed
all
the
valid
data
it
needed.
To
look.
B
E
B
Potentially,
over
under
28
in
the
first
pass
continues.
Okay,
and
if
that
returns
false,
then
you
expand
and
try
again
as
well
only
in
some
cases.
Okay,
so
in
the
in
like
boolean,
it's
pretty
simple
straightforward.
We
ask
that's
always
the
same
sizes,
so
we
have
some
optimizations
there
in
the
case
of
int.
The
only
weird
case
is
if
it
started
with
a
plus
or
minus
and
then
stuff
like
quit,
like
you're
special
you
wouldn't
do.
It
is
a
special
case.
Then
it's
okay
I'll
do.
B
B
Break
right
like
if
we
added
another
format
to
int
like
they
took
something
other
than
a
plus
or
minus
at
the
beginning,
then
we'd
have
to
go
back
and
do
that's
the
only
one
we
had
well.
That
means
that
whatever
standard
format
is
updated
in
utf-8
parser,
you
might
meet
up
to
this
as
well,
hopefully
never
right,
so
that
was
the
only
one
where
I
took
a
bet
that
like
it
would
be
this.
This
is
enough
of
a
heart
I,
just
like
plus
or
minus
it's
actually
more.
It's
it's
more
aggressive
than
that
yeah.
B
It
says
if
it's
under
this
care,
because
we
want
make
the
checks
fast,
I,
say
yeah.
If
there's
only
one
character
and
it's
under
this
character
number
then
I
go
to
the
next
path.
I
could
make
them
always
if
it's
one
character
and
stuff
like
that
and
go
through
the
rest
of
the
thing
we're
doing.
It
bites
instant
arguments
on
the
extension
methods
we
have
out
in
bytes
consumed
because
you're
not
advancing
the
reader
or
are
you
I'm?
B
Try
read
out
read
parts,
but
it's
driving
in
well,
because
we
found
that,
like
keeping
track
of
that
yourself
is,
it
is
expensive
getting
consumed
and
we
like
doing
the
dip
on
your
own,
but
truck
does
not
know
how
many
did
I
lost
it.
I,
don't
know
how
many
it's
like
in
my
internal,
but
back
in
our
state
I
can
update.
I
B
So
you
can
calculate
it
from
the
existing
properties
on
yeah.
Of
course
you
can
do.
But
like
we
just
the
operation,
you
did
pack
bars.
You
know
you
didn't
I
didn't
know
what
the
it
was
that
mean
I'm,
sorry,
but
we
just
gave
you
the
end.
Yeah
I
did
it.
Why
are
you
asking
me
that
that
way
the
like
way
enough,
but
you
can
already
get
the
estimation
yourself?
Well,
that's
when
I
added
this
specific
will
be
the
bikes
consume
yeah.
B
It
was
done
as
an
optimization
because
getting
getting
the
current
count
and
then
getting
it
again
was
just
measuring
so,
but
what
do
we
even
need
it
like
in
what
you've
got
since
in
there?
You
do
not
need
it.
It's
a
convenience
factor.
Yes,
but
it's
it's
a
convenience
factor
that
all
callers
are
paying.
B
Even
if
they
don't
need
well,
it's
always
being
constructed,
though
so,
should
be,
because
the
underlying
thing
that
does
it
is
that,
because
we're
basically
we
do
have
it
wrap
it
up,
but
we
have
probably
over
I,
think
there's
another
one
on
the
extension,
but
because
I
mean
just
but
this
is.
This
is
oh
another
example
of
what
I
mentioned
earlier
about
I
think
we're
changing
the
public
API
surface
for
like
a
performance,
optimization
that
either
a
few
people
need
or
another
chicken
Big,
Brother,
yeah
and
I'm
fair
with.