►
Description
-14:-40:-02 - Approved: PipeReader and PipeWriter implementations over a Stream https://github.com/dotnet/corefx/issues/27246#issuecomment-461567272
A
B
Pipes
awesome
awesome,
new
tech
that
we
built
super
fast
tech
car
to
use.
In
some
cases
we
want
to
have
it
I
thought
just
for
for
going
from
pipe
to
stream.
It's
dream
to
pipe,
let's
dry
there
and
it's
been
at
Quarry
exploding
pipelines
on
the
actually
to
be
context,
but
we
still
have
to
stream
so
yeah.
B
We
have
to
do
this
trick
where,
if
you
replace
the
pipe
or
the
stream
and
get
either
one
it
has
to
work
so
we're
doing
all
kinds
of
checks
any
of
that
work
and
in
the
in
the
meantime,
you
got
to
actually
write
adapters.
Let
go
from
pipe
to
stream.
Extreme
too
tight,
please
exist
already
in
various
forms
and
in
different
libraries,
and
they
want
to
make
it
like
a
first-class
thing.
In
pipelines
we
couldn't
have
two
main
API
is
one
that
goes
from
height
to
stream,
and
then
it
streams
of
pipe.
B
Just
for
them
yeah
and
gets
the
first
one.
The
first
one
are
extensions
on
the
actual
pipe
feet
of
pipe
writer.
Let's
roll
up,
but
in
fact,
if
Fe
out
there,
if
you
want
to
go
from
a
pipe
route,
so
it's
to
a
readable
stream.
You
call
pipe
through
a
stream
there's
a
bullet.
We
will
talk
about
later
on
I
printer,
the
same
thing.
If
you
want
to
go
from
pipe,
but
it's
too
extreme,
you
call
it
hot
stream
and
then
for
a
duplex
pipe.
B
B
D
D
D
B
The
answer
immediately
is
everyone
who
wants
to
use
this
if
they're
passing
a
stream
to
a
library,
they
don't
understand,
is
they're
not
gonna
wrap
this
stream
with
another
stream
that
just
does
sink
over
a
sink
yes,
so
we
should
do
that
because
Steve
knows
how
to
do
it
the
right
way.
There's
no
there's
no
right
way
to
do
it.
There's
this!
It's
okay,
there's
some
there's
no
good
way
to
do
that.
It's
mostly
this
is
mostly
like.
B
B
Don't
care
if
you
go
through
that
much
pain
to
do
blocking
calls
and
that's
your
problem.
This
is
more
like
hey.
If
you're
doing
the
wrong
thing,
you
know
because
we'll
throw
and
then,
if
you
want
to
actually
go
through
the
pain
and
work
around
it,
you
can
call
possum
faults
and
then
you,
you
can't
perfect,
going
to
know.
B
Ban,
if
you
don't
know,
then
you
won't
have
a
problem,
but
if
so,
you
today
is
I
turn
a
scale.
You
get
it
professor
and
you
can't
really
fix
it
and
you
don't
notice
too
late.
In
this
case
it
would
throw
from
the
get-go
it
wouldn't
even
like
pass
to
begin
with.
So
you
wouldn't
be
an
executor
where,
where
it
kind
of
works
for
now,
but
then,
as
you
get
more
skill
it,
it
starts
sleep
here.
G
B
C
It
feels
very
weird
to
me
why,
because
there
are
API,
is
that
we're
basically
saying
do
you
want
these
to
work
or
not,
based
on
a
boolean
that's
passed
in
and
we
can
make
them
work?
They
just
don't
perform
the
way
we,
ideally
they
don't
perform
the
way
you
would
use
different
overloads.
This
is
basically
like
a
a
knob
solution
mechanism
or
something
that's
controlled
via
parameter
to
a
method.
It
feels
very
strange.
I
B
I
B
A
Say
that's
slightly
different
I
would
say
that
the
that
kind
of
depends
on
how
you
evolve
the
basis
of
life
from
the
get-go
right.
So,
for
example,
if
you
look
at
our
collection
library
of
stream
API,
they
always
had
the
mode
of
like
what
collection
might
be
readable
or
my
favorite.
Only
the
stream
might
be
see
Keable
or
it
might
not
be
sick
of
alright.
So
as
soon
as
you
start
consuming
a
stream
from
day
one
you
design,
your
API
is
along
those
lines,
but
it's.
A
I
say
X
document
or
load.
Well,
you
would
expect
it
to
you
know
not
right.
So
if
we
would
write
what
you
were
expected
to
fail,
the
problem
here
is
that
from
the
get-go
stream
heads
from
corners
api's
later
on,
we
edit
asynchronous
API
is
now
you
live
in
the
world
where
it's
very
hard
for
a
customer
to
reason
about
which
streams
support
it,
because
it's
kind
of
completely
orthogonal
to
the
actual
thing
versus
read
verses
right.
Well,
it's
kind
of
obvious
the
things
like
in
this
case.
A
B
Think
of
it
more
like
think
of
it
more
like
buddy
calls,
will
stop
you
in
the
rest,
and
if
you
want
to
work
from
that,
that's
anything
is
passing
through
training
and
then
your
opportunity
to
kill
yourself
where
it's
not
it's
not
really
like
a
thing,
and
by
the
way
this
is
a
hill
I'll
die
on
I.
Put
it
in
there
to
have
a
discussion,
so
I'm
fine
having
it
not
down
there.
It's
true
and
it's
gonna
curb.
We
will
move
rapid
stream
ourselves.
D
E
D
C
E
D
A
D
A
But
the
problem
is
180
is
like
three
different
kinds
of
streams,
and
so
the
problem
there
was.
We
also
tried
to
make
it.
So
you
can
go
back
and
forth,
so
you
can
take
a
win
at
each
stream,
get
to.net
stream
and
then
go
for
the
door
net
stream
back
to
the
party
stream
as
all
extension
methods,
and
we
try
to
preserve
identities.
If
we
go
back
and
forward
on,
we
allocate
so
we
have
a
McIntyre.
A
The
problem
that
we're
doing
any
case
is
that
I
am
not
convinced
that
you
know
all
these
extension
methods
are
discoverable,
because
if
you
look
at
the
winner
team
epoch
that
we
have
gotten
is
people
couldn't
learn
how
to
use
the
API
in
general,
and
it's
not
sure
that
the
problem
is
extension
methods.
It's
also
that
they're
streaming
API
czar
substantial,
more
difficult
than
ours.
I
was.
C
C
B
D
B
B
B
C
D
When
one
scenario
for
all
the
implementation
is
you're
exposing
create
method
that
creates
a
reader
from
a
stream,
now
that
we've
doing
what
well
but
yeah,
so
we're
not
there
yet,
but
imagine
that
I
have
a
white
reader
that
was
created
from
a
stream.
If
I
now
call
a
stream,
it
would
be
nice
if
it
just
gave
me
this.
D
A
D
N
A
H
O
O
D
Be
different
context,
what
no
no
I'm
saying
one
stream
time
but
before
I
was
saying:
why
do
we
have
extension
methods
we
could
just
expose
the
stream
type
and
people
use
the
constructor?
So
yes,
and
where
we
have
three
different
implementations
on
the
street
right
now
we
added
the
other
methods
as
been
to
our
methods
to
read
a
writer
and
we
just
expose
expires.
Three
I
have.
C
C
H
F
B
B
E
E
K
A
Expose
this
really
that's
not
like
do
both
things
well,
the
one
benefit
of
exposing
the
tribe
is
that
if
you
want
to
customize
like
if
it's
the
current
Airstream
works
for
you
almost
but
not
quite,
if
you
only
have
the
extension
of
the
only
the
workshop
methods,
you
have
to
implement
the
entire
thing
from
scratch.
So
if
you
expose
another
type,
you
can
just
drive
from
that
into
wherever
you
want.
B
C
I
sort
of
led
us
down
this
path,
but
maybe
imposter.
You
say
this
one
step
at
a
time
and
we
start
with
basically
whether
it's
static
extensions
are
virtual.
We
start
with
basically
as
stream,
and
then
we
see
how
far
that
gets
us
and
everyone
we
see
if
you
should
expose
something
else,
yeah.
So
what
we
learn.
C
A
B
Like
the
reason
that
I,
like
the
nut,
skirt
the
constructor,
perhaps
in
addition
to
the
preschools
on
the
reader
and
the
writer,
is
that
it
it
it,
it
makes
there
be
symmetry
on
there
for
the
three.
The
fact
that
the
I
duplex
pipes
an
interface
and
we
don't
have
default
interface
implementations.
Yet
it
is
going
makes
it.
B
A
A
B
O
H
C
C
N
C
C
D
A
O
G
A
O
P
Q
B
D
N
B
N
B
So
the
first
one
is
pine
tree
dot
create.
So
given
a
stream
of
input
create
a
pike
reader.
We
had
this
time.
Was
this
the
same
I
say
but
yes,
a
much
char
cloth
and
you
pop
the
options.
I
look
at
later,
I
guess
in
the
sample
pipe
writer
you
huffing
this
Jim,
you
get
a
typewriter
back
and
then
we
add
coffee
to
a
saying
which
copies
from
a
pipe
reader
to
a
to
a
screen
and
then
copy
from
a
sink
which
goes
from
typewriter
from
stream
to.
B
C
D
B
B
B
B
H
B
C
H
C
B
B
What
do
we
do
internally
was
that
it
would
basically
create
pipe
internally
and
then
from
the
right
side,
pass
that
to
the
stream
and
then
explode
to
view
to
the
actual
color
right
and
require
kind
of
a
backgrounds
has
to
run
copying
data
from
the
breadth
of
the
green
side,
and
we
didn't
wanna
do
that
so
to
make
it
to
make
it
less
of
less
fire,
forgetting
and
kind
of
weird
we
wrap
the
stream
directly
and
just
create
a
pipe
reader
over
that
screen.
So
it's
more
full.
C
E
J
H
D
D
O
K
B
B
B
G
B
H
B
J
O
A
Q
It's
like,
if
you
call
initially
trench
coat,
we
call
try,
read
because
if
there's
already
some
data,
that's
been
buffered,
she
just
returned
that
call
diary
or
if
you
call
tree
you
sink,
and
if
that
segment
size
is
too
small,
then
we
want
to
call
actually
call
releasing
that's.
Why
I
won't
we
use
buffer.
B
So
if
we
have,
if
we
have
the
main
threshold
left
in
the
buffer,
that
we
write
it
in
the
pool,
we
get
a
new
upper
consider
using
the
why
I
trying
to
have
or
not
do
small
read.
So
if
you,
if
you
don't
read
any
and
you
end
up
with
bucket
at
best,
that
is
our
build
up
to
200
bytes,
we
don't.
We
won't
pass
that
those
to
the
next
read.
Okay,
new
penny
buffer,
but.
H
B
E
D
H
D
B
B
H
B
H
B
You
were
going
to
go
from
a
pool,
read
from
a
stream
and
then
return
right.
You
know
in
a
loop
over
and
over
from
a
pool
of
some
size
brief
in
a
stream.
You
get
a
name.
I
st.
hope
was
right.
You
have
two
options
returned
from
the
pool
it
directly
r-rita
buffer
over
over
right.
We
want
to
read
the
buffer
as
long
as
there's
space.
That's
just
useful
in
it.
B
If
you
refuse,
if
you
read
it
before
cake
from
the
pool,
you
call
read
in
the
stream
and
then
you
read
one
one
bite
you
want
to
keep
using
that
same
fork
until
it's
drained
you
dr.
Brown,
returned
like
Oh
over
over
this
thing
just
says:
I
want
to
rent
4k
because
4k
by
default,
the
buffer
size,
that's
one
one
setting
the
other
one.
Other
one
says:
how
much
do
you
leave
in
that
buffer
before
I?
Consider
it
useless?
How
many
thought
we
say
is
here?
Why.
D
B
B
Happens
in
Orillia
Canada
what
up
CF
for
some
of
the
services?
If
the
read,
if
you've
used,
let's
say
you're
using
half,
so
if
you've
read
three
K
out
of
a
fork,
a
buffer,
you
are
then
moving
with
the
rest
of
the
1k,
or
is
it
that
because
this
is
where
you're
right
up
to
that,
you
only
have
one
K
left
to
fill
in
the
next
week.
Oh
I
want
I,
always
want
to
hear
East.
H
B
Q
D
N
B
B
D
You
can
change
it
if
you
know
so.
Another
thing
you
could
do
is
especially:
if
you
take
to
change
these
types
into
strands,
then
they
can
be
get
set.
So
we
have
a
different
contractor
and
then
you
have
well
all
you
have
any
most.
You
have
a
constructor
that
takes
the
things
that
you
absolutely
need
and
then
other
properties
being
dead
set
and
the
reason
if
you
make
them
struct
once
you
pass
it.
They
are
kind
of
in
here,
and
you
know
they
are
you'd.
D
H
K
H
H
B
K
B
H
B
N
B
H
Doing
birthday
parties
like
somewhere
learn
to
get
another.
We
you
implement
reader
then
by
previous
week,
all
right,
not
like
your
interface
enterprise
you're,
getting
its
pipe
reader
yeah.
It
has
good
memory,
so
somebody
not
exactly
memory
properties
hasn't
freaked.
Oh
sorry,
sorry,
yeah,
they're,
they're,.
B
B
Q
D
B
F
Q
Q
C
L
B
B
B
H
Exactly
why
there
is
a
minimum
segment
size
on
the
implement
bumper
rider
right.
So
some
when
somebody
calls
get
murmuring
in
freedom
and
passes
you
one
what
you
don't
want
to
rent
block
of
size,
one
from
memorable,
because
the
right
memory
pool
would
give
you
like
one
or
two
or
five:
wherever
is
the
minimum
size,
so
you
want
to
have
some
minimum,
so
the
whether
you
get
into
get
memory
is
aligned
with
these
minimum
size
and
mag
size
from
buffer.
And
this
which
use.
C
H
Compression
middleware
and
your
transport
is
a
pipe,
but
the
only
way
to
compress
stuff
is
a
compression
stream.
So
you
do
a
compression
stream
copy
to
HTTP
response
that
body
pipe
and
we
weren't
allocating
there
before
so
allocating
another
stream
just
to
copy
bytes
from
one
place
to
another.
Make
sense
so.
D
B
That
I
feel
as
though
this
is
a
bit
more
natural
to
do
copy
to
a
sink,
mostly
because
we
have
it
ready,
in
that
case,
you'd
end
up
doing
body
pipe
copy
from
a
sink
yeah
virgin
stream.
So,
okay,
let's,
let's
add
so
the
problem
is
we'll-
have
an
extension
method
on
stream
in
the
pipe
for
her
namespace.
That's.
B
O
B
D
D
A
C
A
D
O
H
B
O
D
B
The
extension
method,
kappachu
I,
think
against
stream
works
because
it's
if
somebody
was
copied,
if
somebody
already
is
doing
stream,
get
a
strange
dream.
This
will
tell
them,
don't
call
the
conversion
and
wrap
this
with
another
stream
will
undo
this
call
for
you.
So
all
that
this
will
do
is
build
a
virtual
on
pipe
round.
Let's
do
both,
so
this
is
just
a
translation
so
that
you
hit
the
existing
pattern.
M
B
Matter
what
we're
going
to
have
this
copy
copy
to
a
saying
from
spoon
typewriter,
that's!
That's
there,
regardless
person
is.
Do
we
have
that
implementation
called
hyper
here,
not
copy
from
async
stream?
Can
we
still
have
the
fertility,
but
does
the
copy
from
a
stream,
and
you
seem
to
rename
that
copy
from
anything
to
write?
Doesn't.
B
B
B
B
B
C
C
I
think
I
think
these
streams
can
be
pretty
small
and
if
they
are
small,
that
I
would
expect
it
to.
In
the
case
word
possibly
small.
Presumably
you
would
actually
want
to
be
returning.
Evalute
ask
a
flush
result.
Just
like
the
existing
ride.
A
sink
does
value
tasks.
A
flush
result
seems
like
it
really
is
just
another
little
another
overlook
a
sink
there.
B
B
C
There
are
some:
there
are
some
downsides
to
value
tasks
if
all
you're
doing
is
you're
just
awaiting
it,
and
you
know
if
you're
getting
benefits,
because
the
thing
you're
calling
is
using
a
cool
dye
value
task,
source
and
whatnot,
then
value
task
is
a
clear
win
or
if
it's
synchronously
returning
and
it
returns
a
result.
So
it's
a
value
task
of
tea,
but
value
task
is
a
larger.
It's
a
struct,
that's
larger
than
you
know,
a
single
pointer.
C
B
B
M
B
B
H
C
C
Q
O
O
B
Thank
you.
A
second
copy
from
I
think
I'm
thinking.
If
you
called
Castle
painting
right
but
have
any
luck
there
yeah,
we
should
break
the
loop
and
return
to
the
results
and
return
the
counselor
result.
Well
in
that,
but
there's
a
similar
analogy
would
seem
like
the
flush
is
all
in
the
lead
result
as
far
as
like
use
cancel
okay.
This
to
me
this
is
just
an
overloaded
by
anything.
G
B
Yes,
I
mean
okay
to
be
fairly.
The
same
poster
stream
right
in
could
have
been
Jim
companies
in
could
have
been
caused
to
not
right,
I,
think
the
difference,
dream,
yeah,
I
think
Christophe
just
said
he
wished.
It
was
called.
Other
platforms
have
the
same,
like
Sogo
has
copied
to
a
copy
from
the
same
with
they
are
viewers,
I
thought
I
thought
it's
not
a
bad
thing,
it's
just
a
different
name.
Is
it
it?
It's
a
bigger
thing.
One
thing
all
right
a
case,
multiple
right
in
discussing
the
call,
but
it
seems
to
be
chunkier.
B
C
D
B
B
E
D
B
O
B
C
B
B
C
I
mean
it
sort
of
in
an
ideal
world,
you've
got
copy
to
racing
from
stream
to
pipe
and
you've
got
copy
tracing
from
pipe
to
stream.
We're
not
doing
a
virtual
copy
to
a
sync
on
stream
because
of
layering
and
not
whatnot,
but
having
the
extension
method
and
then
a
protected
internal
copy
from
you
think
kind
of
achieves
the
same
thing.
Yeah
nice.
A
P
A
Virtual
method
on
stream
I'll
be
two
async
that
takes
a
destination
stream.
I'm
asking:
are
you
overwriting
this
especially
case
the
case
that
the
stream
that
was
passed
in
the
stream
that
was
produced
from
the
fibrotic?
Would
that
help?
Well?
The
question
is
whether
you
have
a
scenario:
that's,
of
course,
we
won't
expect
it
automatically.
So
didn't
aim.
G
Q
B
C
J
C
Suggestion
is
we
go
with
the
protected
internal
copy
for
me,
saying
and
I
only
say
that,
because
copy
from
a
sink
is
such
an
unusual
name
and
on
net
that
it's
kind
of
nice
to
hide
us
in
the
public,
Caesarea
yeah.
And
then
we
go
with
that.
Kestrel
plumbs,
it
all
the
way
through
and
we
see
if
we
had
any
issues
and.
C
That
if
we
think
that
there
are
optimizations
that
can
be
done
by
returning
value
tasks,
ray
I'm
a
little
skeptical,
but
you
know,
given
that
we're
talking
about
this
living
on
pipe
rider
and
pipe
rider,
is
doing
caching
of
stuff
already
and
I.
Think
it's
already
implementing
I
value
tasks,
source
and
whatnot,
then
maybe
it
actually
could-
and
so
in
that
case,
like
vibe
right
or
not
right,
right,
async,
today,
on
pipe
writer,
that's
already
returning
a
value
test
that
wraps
an
I
value
test,
source
right,
yeah.
O
G
G
B
B
Think
maybe
the
only
thing
don't
work
earnest
it:
the
wrong
for
cancellation
fees,
protected
internal
value,
task
of
melon
on
plus
result.
Let
me
sing
hold
on
hold
on
hold
on.
Instead
of
that,
let's
keep
it.
Let's
make
a
task
I'm,
just
throw
for
past
vision,
yeah
I'm,
fine!
With
that
yeah.
It's
clean
away!
Well,
join
you
right!
Now,
goods
like
the
result,
type
type
stuff
on
them.
Not
what
do
you
make
sense
it
in
the
pipe
case
not
like
it
was
completed
like
in
the
normal
right,
yeah
I,.
E
G
D
B
B
B
O
Q
B
B
Usually
the
earlier
and
fails
is
if
that
operation,
roads
like
Rita
right
with
the
drawer
you've
stopped
yeah
throwings
on
the
reader
completes
makes
more
sense.
Actually,
we
did
throw
yeah
almost
like
cancellation,
because
the
only
way
for
copy
async
to
successfully
complete
today
with
like
the
stream
api's,
is
reading
the
entire
stream,
which
wouldn't
be
the
case
with
what
we
were
talking
about.
You
doesn't
matter
for.
C
B
There's
one
case
where
you
have
natural
pipe
where,
if
the
reader
said
is
complete,
where
it's
done
consuming
buffers,
but
there
are
still
going
the
the
loop
in
comforters
and
can
stop
I
say
if
we
chose
if
we
chose
to
make
it
stop.
So
there's
like
an
additional
way,
probably
to
stop
that
wouldn't
happen,
which
is
screams.
That's
not
exciters
typically
do
today.
In
that
situation
they
stop
and
and
do
what
they
stopped
producing
so
so,
for
example,
in
Castrol.
B
C
B
What
I'm
trying
disease
I'm
trying
to
think
about
it,
because
you
normally
clean
up
the
connection
when
the
raw
you
know
SSL
screen
was
done
producing
data
to
so
this
is
like
really
any
different
from
the
caller
of
poppy
to
ASIC.
That's
kind
of
what
I'm
trying
to
figure
out
is
to
the
return
value
indicate
why
copy
to
basic
completely.
B
B
C
J
C
H
C
B
L
A
I
E
B
H
O
B
M
E
M
E
A
Only
reason
why
we
put
the
existing
API
says
comments
is
because
they
want
to
indicate
on
the
new
API
is
fitted
with
the
old
ones.
This
is
usually
useful
for
over
those
or
other
things
when
you
really
want
to
see
the
other
ones
in
class,
otherwise
nobody
cares.
The
only
thing
that's
important
is
like.
If
there's
a
new
tie
Briony,
what
does
an
existing
time
and
partial
kind
of
is
or.
P
A
L
A
O
H
To
be
is
and
buffer,
so
we
have
this
very
convoluted
error
in
pipe
when
the
rider
is
awaiting
big
pressure,
so
it
cross
the
blood
pressure
threshold
and
leader
needs
more
data
like
it
looked
at.
The
data
is
currently
has,
and
it
says,
I
need
more
data,
it's
a
deadlock
situation
because
one
can
I
Drive
more
and
the
other
cannot
reach
because
it
needs
more.
Does
it
yeah?
H
B
Size
that
is
less
than
the
per
month,
all
right.
So
to
give
you
some
context,
you
know
obviously
pipe
handles
a
lot
of
your
buffering
for
you,
while
you're
parsing,
like
link
prefix
things
right
so
for
Kestrel,
parsing
headers.
We
let
you
actually
configure
this
yeah
this
max
buffer
size,
vehicle
options
and
if
it's
only
Kestrel,
parsing
its
own
headers
and
stuff.
That
will
be
fine,
because
when
you
actually
start
capturing
when
you
construct
it,
it
will
fail.
If
you
basically
set
a
buffer
limit.
B
B
K
C
H
B
D
D
K
B
Thought
all
right,
but
imagine
you're
writing
the
code
that
puts
up
the
dialog
box
or
your
Kestrel
and
you're
trying
to
show
them
where
to
configure
this
in
catch
two
options.
Are
you
single?
Are
you
trying
to
tell
the
developer
where
to
configure
it
in
single
or
option,
and
also
you
can
catch
that
exception
type
and
then
throw
a
single
exception
or
a
casual
exception,
or
something
that
gives
you
details
on
how
to
actually
configure
it
for
your
framework,
but.
C
B
H
What
are
you
thinking?
How
would
you
like
us
max
read
size
into
releasing
yeah
like
I,
want
to
read
to
geeks,
no
matter?
What's
your
limit
isn't
override
by
pressure
limit
that
I,
don't
first
gear
and
pipelines,
but
it's
too
late
yeah,
so
things
like
that,
but
this
exception
will
still
be
thrown
in
some
cases,
but
will
give
you
a
way
to
do
better
work
right,
yeah,
you
better
work
around
the
just
increasing
buffer
sizes
somewhere
or
rewriting
your.
H
B
H
B
Five,
how
you
fix
it,
though
we
get,
would
always
be
a
risk
that
someone
using
pipes
directly
could
go
over
that
limit
and
if
you
want
to
tell
them
how
to
reconfigure
single
are
like
you
have
a
better
error
in
pipes
regardless
I
think.
The
only
difference
is
that
if
you
are
consuming
a
pipe,
you
have
to
kind
of
know
the
limit
and
set
your
limits.
I'm
gonna,
throw
better.
B
D
H
C
H
T
H
D
B
H
C
I
have
a
bread,
dumpling,
okay,
this
is
for
like
a
weights
right,
yeah,
yeah
I
mean
right
now
it
was
originally
written,
applying
to
normal,
continue
it's
and
then
it
just
never
got
propagated
or
refactor
to
apply
to
every
other
kind
of
continuation.
We
would
need
to
measure
it
and
make
sure
it
didn't
things
significantly,
but
my
guess
is.
It
would
be
mostly
within
the
noise
very
strong
concerns
we
just
never
did
it.
H
C
H
H
B
C
H
N
B
I
do
have
a
question
for
you
that
if
we
add
a
taxpayer
that
supports
puff
writer,
where
will
I
go
in
the
framework,
I
prefer
others
in
the
system
memory.
So
that's
fun
wearing
is
fun.
Where
could
we
add,
API
send
Betty
to
interrupt
between
system
memory
stuff
and
like
retina,
PCL,
I?
Think
boy
Carla,
no.