►
From YouTube: GitHub Quick Reviews
Description
Powered by Restream https://restream.io/
A
A
A
A
A
B
B
And
so
far
we
have
been.
You
know,
hardcoding
this
magic
constant
all
over
the
place,
and
it
would
be
nice
to
have
api
for
that
so
that
you
don't
have
to
hardcode.
It.
C
E
B
F
Yeah
this
actually
just
came
up
a
week
or
so
ago,
where
yon
reactivated
this,
because
the
implementation
of
a
ray
buffer
writer
would,
you
know
double
double
double
and
then
had
a
a
couple
issues
with
it
one.
As
soon
as
you
hit
one
gig,
it
tries
to
double.
You
know:
it's
gonna
hit
auto
memory.
So
then
you
end
up
with
kind
of
a
poorer
utilization
of
memory,
because
you
try
to
double
from
one
to
two
and
you
get
out
of
memory.
F
So
then
the
algorithm
previously
tried
to
increment
by
a
little
bit
it
didn't.
It
didn't
really
know
how
much
to
ask
for
so.
Basically,
I
I
had
I
created
a
pr
because
it
appeared
to
almost
hang
due
to
perf,
because
it
was
constantly
allocating
memory
as
the
buffer
would
grow.
F
So
this
is
just
an
implementation
of
a
ray
buff
writer
that
we
have,
but,
as
young
pointed
out,
others
may
want
to
do
the
same
thing
and
they
just
don't
know
what
magic
number
to
use.
C
Sure,
but
I
think
like
if
you're,
if
you
have
one
billion
elements
and
you're
clamping
to
a
number
close
to
two
billion,
like
you're,
probably
going
to
cause
some
other
part
of
the
system
to
at
some
point,
because
almost
certainly
you're
not
going
to
use
the
additional
one
billion
slots
that
you
just
allocated,
it
seems
like
a
better
solution
would
be
once
you
approach
some
threshold
instead
of
using
two
as
your
multiplicative
factor
use,
1.1
or
something.
C
Sure
so
yeah,
so
this
number
makes
sense
in
64-bit
applications
where
you
have
enough
memory
to
do
that.
But
what
I
guess,
what
I'm
afraid
of
is
that
if
we
expose
this
and
then
we
tell
libraries-
oh
just
double
and
clamp
to
this,
like
there's
going
to
be
a
significant
number
of
scenarios
where
you
actually
haven't
helped
things
at
all,
you're
still
just
going
to
everywhere
right.
D
B
C
E
C
C
G
C
Yes,
but
if
we're,
if
we
have
scenarios
where
doubling
actually
causes
problems-
and
we
should
change
those-
we
should
change
that
logic
within
the
collection
types
that
are
experiencing.
That
problem
and
clamping
to
this
number,
I
don't
think,
would
be
the
appropriate
way
to
solve
that
issue
within
our
collection
types.
I
think
the
appropriate
way
would
be
to
use
a
different
growth
factor.
D
C
C
Suggesting
people
do
instead,
I'm
suggesting
that
if
you,
if
you
have
a
growth
algorithm,
you
change
your
multiplicative
ratio
from
two
to
one
point
one
or
something.
Once
you
exceed
some
threshold,
it
would
still
be
advertised.
C
H
I
think
it's
fine
to
say
every
place
in
our
code,
which
is
more
than
I
can
count
on
one
hand
where
people
hard
code,
the
value
and
you
can
search
customer
code
bases
and
the
value
is
hard-coded
yeah.
It
is
a
step
in
the
right
direction
to
say,
use
this
this
api.
Instead,
if
we
want
to
then
go
a
step
further
and
address
say
well,
your
whole
algorithm
is
wrong,
and
so
is
ours
by
the
way,
let's
fix
it,
that's
an
extra
thing,
but
that
doesn't
replace
having
an
api.
F
F
C
G
Oh,
no
max
value
is
still
correct
for
length,
but
not
as
an
index,
which
is
which
are
two
different
things
correct.
Yes,
yes,
and
in
this
case
it's
length
rather
than
index,
so
you
can
also
have,
even
though
arrays
in
dotnet
core
can't
be
max
length
spans.
For
example,
can
I
can
allocate
a
native
array
that
that
that's
that
big
yep
have
to
link
that
and
iterate
successfully
with
a
standard
for
loop.
A
D
E
Excellent
question:
should
this
be
returning
an
int
I
mean
I
know
for
us.
Int
is
reasonable,
but
we
also
have
long.
E
G
B
A
B
Yeah,
so
you
can,
in
theory,
do
tiny
bit
with
arrays
that
that
are
the
long
length
arrays,
but
you
know
it,
it
doesn't
work
right.
It's
like!
Yes,
you
can
allocate
an
index
into
it,
but
you
cannot
reasonably
pass
it
into
any
api
and
expect
that
api
to
work.
You
know.
G
A
More
of
a
fianc
I
would
not
bother
like
I
mean
the
end-to-end
doesn't
work
at
all
today
and
unless
there's
an
actual
scenario
where
somebody
has
code
that
works
this
way
on
a
platform
that
we
care
about,
I
would
not
invest
in
this.
Just
the
fact
that
mono
has
it.
I
don't
think,
is
good
enough
as
a
justification
to
add
the
complexity.
D
A
A
It
up
is
my
thing
frozen
again.
A
Yeah,
it
seems
like
teams
again
cannot
handle
sharing.
So
in
that
case,
let
me
just
copy
paste
this
link
into
chat
and.
A
Yeah,
it
seems
like
I
cannot
send
im
messages
either.
So
it's
the
second
issue
in
the
email.
It's
there
four
or
475.
I
So
yeah
the
feature
here
is:
we
have
existing
apis
for
cancellation,
token
registration
register
an
unsafe
register.
The
the
proposal
here.
What
they
take
today
is
just
an
object
and
a
a
state
that
you
can
pass
in
that'll
be
passed
back
to
the
callback.
The
proposal
here
is
to
add
additional
register
and
unsave
register
apis.
I
That
also
ask
the
cancellation
token
to
your
callback,
turns
out
that
you
almost
always
want
access
to
the
cancellation
token,
because
you,
when
you
are
getting
called
back
on
the
registration,
you
probably
want
to
generate
a
operation
canceled
exception,
and
you
probably
want
to
do
it
with
the
cancellation
token
that
it
is
that
is
causing
the
cancellation,
and
so
what
we
do
in
several
places
in
the
code
today
is
we
have
to
store
the
cancellation
tokens
separately.
I
So
it's
just
a
convenience
thing.
The
impact
on
the
code
is
the
implementation
is
pretty
straightforward.
I
I
Stephen
looked
at
this
and
I
believe
he
is
happy
with
it
and
is
he
on
the
call
today
I
don't
know
yeah
okay,
so
that's
the
the
only
other
thing
to
note
here
is
that
in
the
existing
register
apis
we
have
an
overload
that
has
a
bool
use,
synchronization
context
argument,
but
per
steven's
feedback.
This
is
not
something
we
really
want
to
encourage,
or
that
is
common.
So
we
did
not
add
an
overload
with
that
additional
argument
to
these
to
this
new
set
of
overloads.
A
What
is
the
behavior
if
you
call
the
one
that
doesn't
take
the
bull
as
if
the
ball
was
false,
and
that
would
be
the
same
here
for
these
right.
H
H
H
All
are
basically
exactly
the
same
as
the
existing
method,
names
and
parameter
names.
I
think
the
only
thing
that
you
know
isn't
set
in
stone
is
the
order
of
the
arguments
to
the
callback,
and
I
suggested
we
do
it
this
way,
so
that
it's
kind
of
like
overloads,
where
there's
one
that
just
takes
an
object
and
there's
one
that
adds
a
cancellation
token
after
that.
H
That
also
happens
to
map
to
our
recommendation,
for
you
know,
methods
taking
cancellation
token
at
the
end,
although
this
is
obviously
for
a
slightly
different
purpose,
but
it
just
felt
to
be
a
little
bit
more
natural,
but
if
others
wanted
the
other
order,
that
would
be
okay,
too.
H
Yeah
well,
naturally,
that's
actually
another
good
reason,
but
because
it
often
is
sort
of
that,
but
the
existing
overloads
just
take
action
of
object.
So
you
know
whenever
we
add
new
overloads
of
methods,
we
always
sort
of
think
about
adding
parameters
at
the
end,
rather
than
putting
them
before,
so
that
when
you
graduate
from
one
to
the
next
you're,
just
adding
things
to
the
end-
and
so
this
is
similar.
H
You
can
the
cancellation
token
will
have
already
had
cancellation
requested.
So,
okay,
for
the
most
part,
things
will
be
no
ops.
You
know
if
you
tried
to
register
with
it.
It's
just
going
to
I
mean
you,
it's
just
going
to
invoke
whatever
you
pass
to
register,
so
you
could
kind
of
cause
a
stack
overflow
if
you
really
wanted
to,
but
that
would
be
very
strange.
H
H
So
the
primary
purpose
is
to
be
able
to
use
the
cancellation
token
to
as
part
of
signaling
cancellation
of
something
so
like
if
you
wanted
to
call
some
other
task,
completion
source
dot
set
cancelled.
H
Ideally
you
pass
the
cancellation
token
there,
so
it
kind
of
flows
through
or
if
you
wanted,
to
throw
an
operation
cancelled
exception
that
contained
as
jeff
was
saying.
H
You
want
to
create
an
operation
cancel,
except
if
you
wanted
to
contain
this
token,
you
want
to
be
able
to
say
new
operation
cancels
exception
token,
and
without
passing
it
in
here,
you
have
to
find
it
some
other
way,
which
usually
means
storing
the
cancellation
token,
on
kind
of
what
other
object
you
have
around,
which
might
be
the
state
but
often
isn't,
which
means,
if
you
wanted
the
passive
is
to
say
you
have
to
allocate
some
something
new
to
also
pass
it
in
so
levi's
point.
A
lot
of
uses
of
this
are
just
this.
H
As
the
state
we
did
add
a
you.
You
can
get
the
cancellation
token
from
the
registration.
H
However,
and
so
you
know
what
you
can
do
is
you
can
say,
you
know,
reg
underscore
registration
equals
register,
storing
the
registration
on
the
subfield,
but
there's
then
a
race
condition
where,
if
cancellation
happens,
to
be
requested
before
that
store
completes
then
accessing
the
registrations.
Token
obviously
won't
work
because
it
won't
have
been
set
yet.
D
Okay
and
then
for
some
reason,
apisof.net
isn't
working
and
I
foolishly
had
closed
the
tab,
because
the
existing
one
is
action
of
object,
but
doesn't
take
the
state
right.
H
D
The
callback.
H
Yeah
there
is,
there
is
one
that
takes
an
action
rather
than
an
action
of
object.
H
Okay,
so
you
know,
if
we
really
wanted
to
be
totally
complete,
we
could
have
a
system.action
another
overload
that
took
a
system.action
of
cancellation
system
action
cancellation
token.
But
if
you
care
about
passing
in
the
token
rather
than
closing
over
stuff,
you
probably
also
want
to
pass
the
state.
D
A
A
C
That's
fine,
we
can.
We
can
post
those
links.
So
basically,
this
is
an
api
on
random
number
generator
that
you
give
it
an
int
and
it
returns
a
a
farm,
fresh
byte
array
that
contains
that
number
of
random
bytes.
It's
an
accelerator
for
allocated
byte
array,
call
random
number
generator
dot
fill
over.
D
C
It's
basically
an
accelerator
for
three
lines:
yeah,
it's
just
candy,
it's
candy
the
nice
thing
about
it
is
that
it
allows
you
to
use
it
as
part
of
a
constructor,
inline
initializer,
for
instance,
because,
like
hey
in
inside
of
my
in-line
field
declaration,
I
can
just
call
the
accelerator
rather
than
have
to
create
a
private
function
to
have
like
temporary,
locals.
G
C
C
Yes,
yes,
okay,
the
the
thing
the
thing
about
that
is
for
for
most
applications
that
just
want
to
generate
random
data.
I
don't
necessarily
want
to
force
those
applications
to
understand
the
concept
of
spam
and
that's
what
all
of
our
sample
that
that's?
What
the
sample
code
that
I
had
seen
that
originally
led
to
this
issue
did
and
I'm
like.
C
Well,
if,
if
we're
trying
to
get
people,
if
we're
trying
to
teach
people
about
like
one
particular
facet
of
asp.net
identity,
for
instance,
I
don't
want
to
introduce
spam
into
the
mix
at
the
same
time.
So
let's
have
a
simple
api
to
make
that
scenario
easier
and
then
gradually
they
can
use
other
things
as
time
permits.
J
C
Yeah,
there's
a
there's,
an
api
that
returns
a
random
value
from
some
minimum
to
some
maximum.
It
just
returns
a
single
integer.
It
doesn't
fill
an
inter
array.
It's
used
for
things
like
fair
dice
rolls.
C
I
don't
know
the
the
reason
that
I
don't
know
is
the
scenarios
that
we
had
in
mind
were
just
choosing
elements
from
a
collection
or
rolling
a
die
randomly,
if,
if
you
want
to
shuffle
a
collection
to
to
permute
a
collection,
for
instance
or
sorry
to
shuffle
a
collection
at
that
point,
you
actually
need
to
change
the
min
and
max
values,
as
you
iterate,
through
the
returned
array.
So
any
api
that
just
fills
an
array
with
with
randomly
chosen
values
isn't
going
to
fulfill
that
scenario.
A
C
G
C
C
A
I
mean
my
question
for
these
things
is
more
what
I
think
libra
tried
to
express,
which
is,
if
you
have
constraints
on
what
the
sizes
are
in
the
arrays
you're,
probably
better
off,
writing
a
for
loop
anyway,
and
then
call
the
in
32
one,
because
chances
are
like.
You
know.
You
have
other
constraints
like
oh
yeah.
I
can
only
have
one
number
once
or
something
like
this
right,
in
which
case
you
just
run
into
this
long
tail.
Now,
where
you
want
to
express
all
these
constraints
in
a
single
method,
call.
D
Yeah
I
mean
I'd
say
that
it's
a
combination
of
like
it
it's
complex
and
not
common
yeah.
If
it
felt
like
there
were
common
uses
of,
I
need
a
hundred
random
numbers
between
100
and
107,
then
we
could
consider
adding
it
but
I've
I've.
Never
I've
not
run
across
that.
In
general
usage,
the
the
random
the
I
want.
A
fair
random
element
out
of
an
array
was
why
we
added
the
the
get
in
32.
D
C
Give
keta
mind
also
the
apis
that
we've
been
adding
to
this
type
lately
are
all
static,
apis
rather
than
instance,
apis,
because
we've
basically
told
people
don't
bother
subclassing.
This
just
use
the
built-in
implementation.
B
D
I
mean
the
only
question
to
make
sure
that
people
consider
is
that
get
bytes
is
currently
an
instance
method
that
does
that
fills
an
array,
and
this
get
bytes
is
a
static
method.
That
returns
an
array.
I
don't
think
it's
too
complicated,
but
I
don't
know
of
a
whole
lot
of
other
places
that
we
haven't
in
one
overload
group
a
mix
of
static,
in
instance,.
A
A
C
D
C
A
A
A
I
mean
the
nice
thing
here
is
because
the
get
buyers
just
calls
the
other
ones
who
are
non-static
like
there
wouldn't
be
a
scenario
I
maybe
would
ever
want
this
to
be
non-static,
and
that
will
be
the
only
concern
I
have
but
like
that
seems
fine.
A
D
That
that
overload
changed
the
staticity
of
authenticity.
D
A
D
Okay,
right
so
in
net
three
five,
whoever
had
my
job
at
the
time
added
two
static
members
for
well-known
values
of
provider,
libraries
for
windows,
cng-
and
I
don't
know
when
they
added
the
third
one.
But
it's
been
there
for
a
while-
and
this
proposal
was
just
at
a
at
a
static
for
the
third
well-known
value.
C
D
C
As
in
the
work
around,
today
is
new
cng
provider
of
ms
underscore
blah
blah
blah
right,
yeah.
C
D
It's
gonna
say
I
don't
know
that
we
like
either
of
them
problems
is
the
better
one.
Csp
is
the
worst
one.
Yes,
okay,.
D
Csp
was
nt3
and
cng
was
vista.
A
D
I
mean
if
you
want
to
say
that
all
the
bad
apis
and
that
are
in
system
security,
cryptography,
I
I
don't.
I.
E
A
C
This
is
the
get
non-zero
bytes
one.
I've
actually
been
offline
for
a
few
days,
so
I
don't
know
if
there
was
other
extra
discussion
on
here.
A
C
Yeah
there's
this:
this
is
something
that
that
I
know
steven
and
I
have
talked
about
on
this
issue
before,
which
is
I
I
guess
I
see
I
I
get
nervous
about
marking
things
as
obsolete
if
they're,
if
we're,
never
actually
going
to
remove
it
ever,
but
I
I
guess
steve's
argument,
which
is
a
totally
valid
argument.
Is
you
know
if
we
just
have
an
analyzer
saying
you
probably
don't
mean
to
use
us?
Is
it
effectively
different
from
obsoleting
it,
and
the
answer
I
think,
is
no.
E
A
That
is
true,
although
I
don't
know
actually
that
I'm
thinking
about
this,
I
don't
even
think
the
off
by
default,
is,
is
a
problem,
because
we
have
editor
config
that
we
could
do
that
right.
We
have
one
that
is
for
the
product
that
we
could
say
by
default.
We
say
this
one
is
informational
right.
I
think
the
general
idea
of
analyzers
is
that
to
me,
the
difference
between
obsolete
and
analyzer
is
really
more
about
the
detection
itself.
A
Like
do
you
need
custom
code
to
do
a
a
better
detection
like
do
you
have
to
inspect
the
arguments?
Do
you
have
to
see
what
people
do
with
the
return
video
stuff
like
that
right?
If
it's
just
blatantly
this
api
is
bad,
don't
use
it.
I
see
zero
reason
why
we
would
write
code
for
that
if
you
could
just
put
an
attribute
on
it,
because
it
does
exactly
the
same
thing
whether
we
kill
the
api
ever
to
me
is
completely
orthogonal
right,
because
the
the
the
intent
in
both
cases
is
the
same.
A
You
want
to
inform
the
user
that
they
really
shouldn't
call
the
api
and
in
some
cases
the
replacement
exists.
But
you
know
it's
nuanced.
In
some
places
there
is
no
replacement
and
that's
fine
right
whether
we
remove
the
api.
I
think
is
again
completely
separate
from
this,
because
there
might
be
reasons
why
we
can't.
C
Yeah
and-
and
I
think
it's
actually
good
to
look
at
the
problem
this
way
right,
if
we,
if
you
back
up
and
ask
like
what's
the
actual
problem,
we're
trying
to
solve
the
problem,
we're
trying
to
solve
is,
I
would
like
to
provide
a
better
experience
to
people
who
who
write
calls
to
this
api
to
tell
them
hey,
just
double
check,
to
make
sure
that
you
actually
meant
this,
because
you
almost
certainly
meant
something
else.
Instead,
that's
really
the
only
experience
I'm
going
for.
However,
we
achieve
that
experience.
I'm
I'm
completely
open
to
ideas.
A
C
You
abuse
yeah,
you,
you
are
removing
the
amount
of
entropy
in
the
call,
which
means
that
your
overall
security
posture
is
less
than
you
believed
it
was.
D
The
I
mean
basically,
it's
instead
of
getting
eight
bits
of
randomness
per
byte
you're
getting
seven
and
a
half,
and
so
you
end
up
with
a
lot
less
random
than
you
think
you
have,
and
if
you're
working
with
small
numbers
that
becomes
a
problem,
it
would
open.
G
How
is
that
any
different
than
the
get
in
in
32
between
min
and
max
range.
C
G
G
C
So
if,
if
you're
specifying
a
lower
and
an
upper
bound,
while
you're
generating
a
random
number,
then
that
means
that
you're
basically
trying
to
choose
an
element
from
a
set
like
that's.
Basically
the
scenario
for
it
get
non-zero
bytes
basically
means
give
me
random
data,
except
for
remove
some
entropy
from
the
random
data,
which
there
are
vanishingly
few
scenarios
where
that's
actually
what
you
had
intended
to
do.
C
If
you're,
if
you're
getting
random
data
chances,
are
you're
using
it
to
make
a
cryptographic
key
announce
something
along
those
lines.
All
cryptographic
protocols
should
be
able
to
support
zero.
Just
fine.
C
We
tend
not
to
do
that
except
for
stuff
that
only
the
compiler
is
responsible
for
calling.
C
A
A
The
other
half
doesn't
then
well
it's
a
decision
you
have
to
make,
but
I
think
then,
a
warning
is
not
the
right
way
to
force
people
to
make
a
decision,
because
basically
people
will
usually
just
do
whatever
the
warning
tells
them
to
do
right
and
if
that's
the
wrong
thing
half
the
time.
That's
also
not
the
best
thing
to.
A
I
think
they
to
just
echo
them
right,
like
because
I
mean
I
had
the
same
initial
reaction
that
you
have
tarek
but,
like
I
think
it's
fair
to
say.
If
you
generate
a
secret
in
a
buffer
like
you
probably
want
maximum
entropy
right
and
the
fact
that
within
seven
bits
you
remove
like
half
a
bit
or
whatever
the
actual
math
is,
is
probably
not
great,
and
so
you,
you
might
actually
do
something
way
more
insecure
than
you're
aware
of
right.
So
if
you
would
have
named
the
method,
get
non-zero,
but
it's
less
secure.
D
Like
there
are
four
calls
to
this
method
inside
net
framework,
three
of
them
are
bugs.
D
And
the
one
usage
is
in
the
same
assembly,
so
it
could
have
not
made
this
a
public
member
and
that
one
usage
we've
removed
in
core.
So.
A
H
D
D
But
just
like
his
sharing
in
teams,
emo's
website
is
not
working.
A
So
it
is
the
of
course.
I
already
closed
the
tab
again
because
I
met
like
this.
A
So
gotten
in
getting
on
zero
binds
that
takes
a
bite
array
is
used
by
seven
point
something
percent
and
it
exists
in
dotnet
courses
tool.
A
D
A
It's
37,
but
I
I'm
inclined
to
agree
with
you
that
it
seems
like
I
can't
think
of
a
single
scenario
where
that's
actually
needed,
because
even
if
you
generate
strings,
I
would
not
use
that
method,
because
you
have
unintentional
unintended
unintelligible
strings
anyway
and
if
I
hex
encode
them,
then
I
also
don't
care.
So
I
don't
know
why
people
would
not
like
zero
bytes
in
there.
C
So
if
you,
if
you're
using
it
to
generate
strings
you're,
actually
removing
half
of
the
entropy,
not
0.5
percent
of
the
entropy,
so
have
fun
with
that.
A
A
A
A
I
don't
know
what
you
would
use
it
for,
but
I
have
a
hard
time
believing
that
40
of
api
board
first
parties
generate
secrets.
I
mean
I
don't
know
what
they
would
do.
It
seems
also
far-fetched,
so
they
must
be
doing
something.
I
don't
know
whether
it's
you
know.
I
know
I
I
can
just
guess
random
stuff
like
they
generate
a
color
or
something
right,
and
they
just
happen
to
do
a
by
the
way
with
you
know,
whatever,
whatever
bite
size
they
need
for
the
for,
for,
for
color,
structuring.
C
So
so
maybe
what
we
can
do,
then
is
it
looks
like
maybe
we
have
some
follow-up
items
in
chat
and
we
can
just
follow
up
with
those
figure
out
what
the
impact
of
the
ecosystem
will
be
and
then
just
mark
this
as
neats
work.
A
A
H
I
D
D
C
D
D
A
J
Yeah,
okay,
so
this
is
a
proposed
api
in
the
activity
class
in
the
system
diagnostics
and
this
api
we
call
it
baggage.
J
So
this
is
the
same
idea
what
we
have
done
in
five
release
when
we
added
similar
ebi
for
the
text,
so
in
activity
class
we
have
tags
and
we
have
packages
and
both
of
them
is
a
similar
idea.
It's
it's
just
a
key
value
bears
I
mean
list
as
a
difference
between
tags
and
baggage
is
baggage
is
intended
to
be
transferred
through
the
wire
I
mean
across
the
process.
J
So
it's
similar
idea
so
to
give
some
more
idea
about
like
in
tags.
For
example,
what
like
you
know
in
five
we
before
five
we
have,
we
had
ebis
called
add
tags,
which
is
always
add
a
tag,
even
if
you
have
in
the
list
same
key
that
you
are
going
to
add.
So
the
list
can
end
up
with
multiple
multiple
items,
with
the
same
key
so
and-
and
we
said
that
some
people
want
to
to
to
use
some
other
ebi
or
to
to
have
a
way
that
they
can
guarantee
overriding.
J
J
So
sid
package
is
exactly
similar
idea
here.
So
it's
it's
just
like
if
you
we
already
already
have
also
add
baggage.
So
add
baggage
is
always
adding
package
and
we
cannot
change
this
behavior
because
of
the
compatibility
but
zip
tag
set
package
is
going
to
to
have
the
logic
about
like.
If
you
have
this
all
the
key,
if
you
have
this
key
in
the
list
before
so,
the
new
value
will
override
the
the
old
values
here.
A
J
J
D
J
Like
maybe
we
can,
I
mean,
like
somebody,
will
defend
about
like
adding
multiple,
multiple
items
with
the
same
key.
It's
good.
I
mean
it's
okay,
for
them
I
mean
I
I
wouldn't.
I
wouldn't
go
and
obsolete
at
from
now
I
mean,
except,
if
I
see
if
I
see
evidence
about
like
this,
is
really
messing
up
with
some.
D
J
C
J
J
D
J
D
Says
in
the
issue
that
something
in
asp.net
core
that
causes
a
transfer
because
it
read
it
out
as
a
stack
when
it's
now
loaded
it
into
a
new
one.
It's
the
one
that
used
to
be
last
is
now
first
and
the
one
that
used
to
be
first
is
now
last.
So
it's
it
changes
what
the
api
returns
every
time
you
send
this
thing
across
the.
J
J
Already
already
have
have
effects
for
that,
and
they
are
reporting
this
fixed
to
servicing
to
ensure
that
all
all
the
time
they
will
get
the
exact
same
order,
even
if
it
transferred
through.
D
There,
like
it
just
seems
like
that.
What
what
it's
saying
is
at
that
point
you're
in
a
you're
in
a
very,
not
well
defined
behavior,
because
it
depends
on
who
you're
sending
the
message
to
and
how
they
handle
duplicate
keys.
Do
they
guarantee
that
they're
going
to
read
them
in
the
same
order?
J
Okay,
so
just
to
clarify
about,
like
you
know,
as
I
mentioned
about
internally
for
us,
we
are
storing
it
in
the
last
and
first
out
and
when
it's
transferred
to
the
on
the
wire,
it
will
be
transferred
on
same
order.
So
the
last
one
first
out
and
if
somebody
reading
it
from
the
wire
they
understand.
This
is
the
order
and
it's
up
to
them
to
handle
this
order
so
so
that
the
behavior
is
well
defined,
but
how
people
is
going
to
handle
it.
It's
it's
a
different
issue.
A
A
Okay,
so
what
I'm
hearing
then
is
like
there's
no
reason
not
to
expose
this
api
or
absolutely
the
other
one.
It
just
means
people
have
to
know
what
they're
doing,
but
that's
already
the
problem
today
right
we're
not
really
making
it
verse,
we're
just
saying:
no,
it's
an
easier
way
to
just
replace
the
thing
yeah.
Is
there
no
remove,
because
it's
only
because
you
only
have
add
in
set
right.
J
Yeah
yeah,
that's
a
good
question.
So
in
the
api
that
we
exposed
for
set
tag,
it's
it
include
also
the
remove
if
you
pass
null
value.
So
if
you
want
to
remove
any
item
from
the
list,
your
best
null
value
for
it
or
when.
J
Yeah-
and
this
is
this-
is
the
behavior
we
we
went
with,
because
this
is
what
recommended
by
the
open,
telemetry
specification,
they're
saying
that
if
you
have,
they
call
it
attribute.
Instead
of
tags
there
so
they're
saying
that
if
you
passing
null
values,
this
means
that
you
want
to
remove
this
item
instead
of
adding
items
null
value
because,
like
they
are
saying
that,
if
you
have,
if
you
don't
have
the
item
in
the
list,
it's
exactly
the
same.
If
you
have
the
item
with
the
null
value,
it's
the
same
behavior
for
them.
G
A
A
A
E
So
I'm
guessing
this,
this
api
is
to
open
a
named
mutex
or
something
in
windows
right.
E
A
Fair,
but
let
me
take
a
quick
look
because
I'm.
A
A
A
A
And
so
this
one
we
don't
have,
we
do
have
the
overlord
that
doesn't
take
the
event
handler
rights,
and
that
is
standard
since
1.0
and
this
one
basically
fails
on
linux.
If
you
don't
have
a
name.
Oh
sorry,
this
always
fails
because
you
require
a
name,
but
this
seems
to
be
the
pattern
right.
We
basically
decided
that
we
have
these
echo
apis,
all
these
echo
types.
So
that
would
be
the
pattern.
E
Right
yeah,
I
think
the
api
makes
sense
to
me.
I
don't
know
about
the
mutex
rights
and
semaphore
rights
types.
A
Yeah
I
mean
they
are
effectively
just
the
very
convoluted
representation
of
the
windows
echoes
so
yeah,
there's
not
much
more
to
it
than
that
they
are
about
as
usable
as
you
think
they
are
yeah.
I
mean
it's
unfortunate.
We
went
down
with
this
pattern,
but
like
it's
the
pattern
that
we
have
so
I
think
the
apis
look
fine
to
me.
D
What
pattern
would
you
wish
we
did
instead.
A
D
A
E
Like
it
follows
the
pattern,
the
the
only
call
that
I
have,
I
know
the
open
mutex
function.
It
has
a
parameter
for
inheriting,
like
sub
processes
inheriting
the
handle.
I
don't
know,
if
that's
something
anyone
would
care
about
here.
E
It's
it's
not
there's.
If
you
look
at
open,
mutex,
there's
an
inherit
handle
boolean
and
it's
on
there
for
semaphore
as
well
and
event.
Okay,.
A
D
The
mutex,
which
means
they
don't
apply
when
opening
it.
A
K
E
Oh,
that's,
no
there's
a
boolean
inherit
handle
parameter
and
I'm
curious
what
these
apis
would
set
that
bull
to.
I
guess,
whatever
framework
had
yes
and
maybe
to
avoid
adding
more
apis
in
the
future.
We
expose
that
bull
here.
A
A
D
A
A
F
So
this
is
basically
around
the
json
document
class
that
we
have,
which
is
essentially
a
buffer
of
the
json,
and
then
from
that
document
you
get
these
element,
classes
or
structs,
and
it
implements
on
the
document
implements.
I
dispose,
however,
and
at
least
the
serializer
cases,
and
probably
other
people
as
well.
F
The
display
semantics
aren't
necessary
and
we
don't
want
them,
because
we
want
to
return
a
standalone
element
that
people
don't
have
to
worry
about,
calling
dispose
on
because
it'll
be
like
the
return
value
from
a
property,
for
example,
in
either
case,
there's
a
clone
method
that
was
added
when
we,
when
we
did
the
initial
support
for
this
class
and
the
serializer
uses
that
as
a
workaround
and
there's
a
couple
issues
with
that
one.
The
main
reason
is
it's:
it's
slow.
F
I
found
that
it
can
be
optimized
and
this
particular
area
of
the
serializer
is
actually
very
slow,
so
we
can
make
it
a
lot
faster
and
then.
The
second
reason
is
calling
this
clone
method
on
on
the
document
to
get
a
standalone
element.
It's
just
not
very
obvious,
so
it
probably
you
know
for
those
people
that
need
to
to
use
this.
It
probably
makes
their
life
a
little
easier.
A
F
Yeah
yeah
and
which,
which
clone
will
ultimately
do
it'll,
convert
the
pooled
memory.
It
will
release
the
pool
memory
and
do
a
gcl
and
you
know,
but
now
we
allocated
in
some
cases
anyway,
an
extra
buffer
where
we
didn't
need
to.
A
A
D
I
mean
I
I
I
can
see
the
value.
I
could
also
see
it
being
non-public.
D
D
Basically
and
and
using
this
method
using
the
one
on
json
element.
It
means
that
you're
not
being
an
array
pool
thief,
so
it's
yeah.
It's
probably
an
easier
semantic
to
deal
with,
and
I
agree
with
start
small
and
we
can
build
our
way
up
to
having
all
the
parse
overloads.
If
people
ask.
D
F
I
didn't
actually
prototype
that
method,
but
I
do
know
we
make
a
backup
of
the
reader
state
and
if
there's
an
exception
or
something
that
is
restored.
Okay,.
D
The
one
handy
thing
about
the
mutable
struct
is
you
can
just
copy
it
to
a
local
and
then
on
exception,
just
reassign.
The
ref.
A
F
Yeah
jason
document
has
a
root
element,
so
this
is
honestly
it's
just
returning
the
root
element
from
json
document,
but
making
sure
standalone
in
terms
of
memory.
K
A
Yeah,
so
the
reason
I'm
asking
is
so,
if
you,
I
guess
I
guess
the
problem
exists
in
both
places,
never
mind.
I
was
just
wondering
if
you
have,
because
parse
kind
of
implies
that
the
return
value
matches
the
type
you're
invoking
it
on
so
json
document.parse
gives
you
a
choice
in
document,
but
I
guess
that
would
be
the
same
here,
but
json
eitherman.parser
will
give
you
json
element
yep
and
then
the
parse
value
is
just
specific
for
the
constraint
on
what
this
root
element
could
be
right.
D
A
document
can
only
be
one
value
versus
parse
value,
which
is
you
can
be
in
the
middle
of
a
reader,
and
it
starts
wherever
this
is
and
goes
until
it
ends
and
doesn't
care.
If
there's
remaining
data,
so
I
mean
really
it's.
I
F
D
Parse
value
has
a
different
error,
handling
yeah,
depending
on
what
you're
trying
like
if
the
the
notion
of
you've
called
file.open
and
then
say
jsondocument.parse,
it's
like
you
think
that
this
is
one
json
file
and
you
probably
didn't
expect
that
it
was
a
value
and
then
a
comma
and
then
something
else,
because
what
does
that
even
mean
to
you
versus
parks
value?
Is
you
own?
The
reader?
You
can
see
that
the
reader's
not
terminated.
G
This
is
me
okay.
Basically,
we
have
methods
today
for
converting
a
vector
of
t
to
another
vector
type,
for
example,
byte
s
byte
any
of
the
ten
supported
primitives.
G
However,
we
don't
have
a
generic
implementation
of
this
method,
so
it
is,
if
you
want
to
convert
from
a
generic
vector
of
t
to
another
generic
vector
of
t,
you
currently
have
to
write
your
own
logic
handling
all
10.
If
statements
for
the
newer
vector
types
such
as
vector,
64,
128
and
256,
we
do
have
this
generic
overload
and
had
previously
discussed
it
the
benefits,
the
drawbacks
and
ultimately
approved
it.
So
this
is
just
saying
we
should
expose
a
similar
generic
t
from
t2
method
for
system
numeric,
vector
of
t.
G
It's
likely
something
that
was
just
missed
or
not
considered
when
it
was
initially
implemented
back
in
2014.
D
You
said
10
earlier
I
just
parroted
you,
and
so
you
know
we
probably
would
have
had
a
hesitation
on
that.
But
if
we've
already
added
one
thing
to
a
vector
that
that
has
the
switch
of
all
then.
A
I
mean
it
seems
fine,
I
mean
vector
always
had
both
right,
because
we
some
methods
would
work
for
every
t.
So
we
had
like
you,
know,
apps
of
t,
for
example,
and
there
are
some
very
constrained
because
you
only
wanted
to
expose
certain
operations
for
certain
combinations
of
types,
but
this
seems
like
well.
If
all
inputs
and
outputs
are
legal,
then
it
seems
like
we
should
have
had
the
generic
method
from
day.
One.
G
Yeah,
it
will
still
throw,
of
course,
if
you
try
and
do
like
vector
of
bool,
because
vector
of
bool
is
just
not
supported
right
you're,
not
expanding
the.
A
G
Right,
because
this
is
a
this-
is
effectively
just
a
reinterpret
cast
of
the
underlying
bits
right.
G
C
G
G
Yes,
because
all
vector
of
t
is
fixed
with
it,
it's
fixed
number
of
bytes,
no
matter
what
the
underlying
type
is.
So
a
vector
of
int
will
be
32
bytes
and
have
eight
elements,
while
a
vector
of
byte
will
have
32
elements.
D
A
G
I
I
can,
I
can
ping
her
again
and
make
sure,
but
I
don't
believe
she
had
pushed
back
against
it
when
we
added
64,
128
and
256.
So
I
don't
think
there
would
be
pushback
here
either.
A
G
One
of
the
things
that
was
discussed
with
the
the
the
intrinsic
vector
types
was,
namely
that
we
don't
expect
many
people
to
be
writing
generic
code,
and
then
there
was
a
lot
of
people
that
were
saying
this
makes
it
super
difficult
for
the
cases
where
you
are
wanting
to
write
generic
code.
Please
add
it
and
we
ultimately
relented.
A
A
C
Yep,
I
realized
I
never
muted
myself
on
my
clicking
keyboard.
Sorry,
so
this
was.
This
is
an
api
that,
given
a
char
star
or
a
byte
star,
will
create
a
span
around
that
char,
star
or
bite
star.
Assuming
that
the
pointer
is
I'm
sorry,
assuming
that
the
buffer,
the
pointer
points
to
is
not
terminated,
there
was
a
proposal
to
just
get
the
length.
C
C
Oh
yeah,
okay,
okay,
okay
got
it.
So
what
we
had
originally
approved
a
few
months
ago
were
two
sets
of
apis.
The
first
set
of
apis
took
a
char
pointer
and
a
byte
pointer
and
assuming
that
those
buffers
were
not
terminated,
returned
a
span
wrapping
the
buffers.
The
second
set
of
apis
took
a
char
pointer
or
a
byte
pointer
and
returned
the
length
as
a
new
end
of
that
buffer,
assuming
termination
without
actually
creating
the
span.
The
reason
that
we
had
proposed
both
apis
is
because
fans
can't
can't
handle
buffers
greater
than
32.
C
max
value,
so
by
returning
a
new
end,
we
would
be
able
to
give
you
an
answer,
regardless
of
how
long
the
underlying
buffer
actually
was
since,
at
this
point,
we're
dealing
with
raw
pointers,
there
was
some
pushback
against
that.
Basically
saying
that
hey
do
we
actually
need
to
take
or
return
nuance?
C
Is
there
even
a
scenario
for
this,
or
should
we
return
a
different
size?
Like
a
long
did
I
represent
your
argument
correctly
steve,
I
think
you're
still
on
the
call.
C
This
is
the
this
is
the
api
where
given
hr
star
or
a
byte
star,
we
return
the
length
of
the
null
terminated
buffer
to
you
as
a
new
end
yeah
and
there's
there's
a
sister
api
that
just
gives
you
back
the
spam
directly.
There
was,
I
believe,
concern
that
maybe
we
didn't
need
the
api
that
returned
the
new
into
you.
We
only
needed
the
api
to
return
the
span
to
you
and
you
could
get
the
int
from
the
spam.
C
The
the
scenario
that
that
eliminates
is
the
ability
to
receive
the
length
of
a
buffer,
that's
greater
than
32.
max
value,
but
maybe
we
just
have
that
api.
When
we
get
support
for
large
span,
I
think
we
got
that
if,
when
we
get
support,
this
was
actually
john's
feedback.
Yeah
mine
was
around
the
name.
H
G
Yeah,
I
would
generally
assume
that
a
char
star
is
mutable.
I
would
expect
one
of
the
largest
use
cases
of
this
is
going
to
be
interop
code,
where
it
likely
is
mutable
by
default.
G
Yep
and
if
we
return
span,
it
will
implicitly
convert
except
an
f
sharp
to
read
only
span
true.
C
I'm
just
thinking
back
to
my
own
p
invoke
scenarios
where
I'm
often
changing
the
length
of
a
string.
So
when
I
call
in
the
p
invoke
I'm
giving
it
a
buffer
which
might
just
have
arbitrary
null
bytes
or
null
characters
everywhere,
at
which
point
create
span,
would
be
the
wrong
thing
to
do.
H
G
The
there
there's
also
a
case-
that's
common
in
particularly
in
the
win32com
apis,
where
there
will
be
a
fixed
size
buffer
as
part
of
a
struct
where
it
is
null
terminated,
but
has
a
maximum
potential
length.
G
C
Because,
as
soon
as
it
hits
any
null
character,
even
before
the
full
buffer
has
been
exhausted,
it
terminates
the
span
right
there
on
the
spot.
G
Technically,
no,
okay,
not
not
for
that
scenario,
although,
as
a
general
safety
precaution,
I
think
it's
still
best
practice
to
do
so.
Just
in
case
someone
puts
invalid
data
and
you
want
to
avoid
over
avoid
a
buffer
overrun.
C
Correct,
if
you,
if
you
know
the
max,
if
you
already
know
that
the
maximum
length
is
valid
to
dereference,
you
could
just
create
the
span
around
that
entire
buffer.
What
would
be
invalid
is
to
create
a
span
around
a
pointer
with
say,
int.max
value
as
a
length
and
then
to
look
for
the
null
terminator
inside
of
that.
E
C
C
C
G
Although
we're
just
going
to
initially
implement
it
as
in
max
value
and
find
indexo
right.
H
D
H
A
A
C
That
was
the
original
accepted
proposal.
It
returned
nuant,
but
that's
one
of
the
things.
That's
that's
causing
an
issue.
G
Right,
in
which
case,
I
think
just
the
create
span
from
null
terminated,
is
the
essentially
the
median
between
those
and
doesn't
take
up
an
api
that
that,
I
would
believe,
is
better
suited
to
return
native
end.
C
If
I
say
that
again,
if,
if
we
so
one
of
the
reasons
that
I
wanted
to
return
a
new
end,
not
just
for
what
tanner
said,
but
also
that
this
method
that
returns
a
new
end
by
definition,
can
never
fail,
it
might
crash
the
process,
but
it
can
never
fail.
C
E
A
D
That
the
the
one
that
doesn't
take
a
maximum
length
calls
the
other
one
with
a
maximum
length
and,
yes,
we
have
to
decide.
Will
it
always
return,
get
max
array
length
of
t
or
will
it
you
know
say
like
well?
I
hit
the
end
of
my
search
base
and
didn't
find
it,
but
I
think
we
would
just
call
it
with
what's
the
maximum
legal
index
and
now
there's
a
we
don't
guarantee
that
we
found
a
null.
G
K
G
C
D
Yeah
and
I
mean
steve-
had
the
what
else
would
the
thing
that
just
takes
the
pointer
do
and
while
I
don't
have
an
easy
answer
for
that
off
the
top
of
my
head?
It's
also
not
like
something
that
I
look
at
and
immediately
jump
to
the
conclusion
of
what
it's
doing
it's
it's,
not
that
I
produce
two
answers
for
what
it
could
be
doing.
It's
I
produce
zero
answers
for
what
it
could
be
doing,
in
particular
the
one
that's
bite
star
and
I
think.
D
C
D
C
Yeah
the
bite
stars
for
working
with
asi
or
ascii
and
see
utf-8
some
kind
of
data
that
you're
going
to
interpret
later.
E
E
H
All
right,
there's
a
question
of
did
yeah.
Does
the
there's
already
a
create
span?
Does
the
charge
star
have
greater
affinity
to
that
one
or
to
the
bite
star?
One
sorry.
H
Which
name?
Is
it
closer
to
like
it
there's
already
an
api
called
createspan
that
takes
you
that
that
produces
a
span
from
pointer
like
input.
H
We're
talking
about
adding
two
overloads
here,
one
that
takes
a
charge
star,
one
that
takes
a
bite
star.
We
just
said:
if
we
didn't
have
the
bite
bitestar
one
folks
seem
to
know
what
that
means,
and
it
would
make
sense
to
call
its
create
spam,
but
with
the
bytestar
one
now
do
you
still
call
the
charstar
one
createspan
or
do
you
call
it
the
same
thing
that
you
call
the
fightstar
one
got
it
yeah.
H
H
D
C
H
Not
even
talking
about
reinterpretation,
just
just
p
invokes
right
if
you,
if
you
were
using
char
star
on
the
native
side
and
you
interpreted
that
as
bite
star
on
the
managed
side
or
whatever,
like
my
point
being
we're,
we
have
to
be
extremely
clear
what
we
mean
by
bite
here,
because
only
two
two
meanings
of
it
are
valid.
Every
other
meaning
is
possibly
invalid.
C
C
H
A
It
search
for
the
first
zero.
Well,
my
general
interpretation
would
be
because
it's
a
it's
a
pointer,
you
would
just
say
the
last
element
is
still
the
same
size
as
the
type
to
the
pointer,
and
that
one
is
looked
for
all
zeros,
which
makes
in
in
the
char
star
case.
You
look
for
two
zero
bytes
in
the
by
star
case.
You
look
for
one
zero
byte.
That
to
me
makes
intuitive
sense.
D
D
D
D
H
H
G
C
G
H
D
D
Matches
the
utf-8
string,
implicit
terminator.
B
A
I
mean
my
only
question
is,
if
you,
if
you
say,
create
from
non-terminated
utf-8
or
something
that
to
me
implies
you
validated
it.
It's
actually
valid
utf-8,
which
you
wouldn't
right.
It
would
just
say:
well,
if
you
give
me
something,
that's
not
utf-8,
then
it
might
contain
zero,
bytes
somewhere
and
then
yeah.
You
may
be
out
of
luck,
but.
C
I
I
I'm
not
too
worried
about
validation
here,
because
we
don't
validate
for
char
star.
Rather,
we
wouldn't
validate
for
char
star.
G
I
think
he's
trying
to
find,
I
think,
we're
not
going
to
find
a
good
solution,
no
matter
which
way
we
look
at
it,
either
we're
we're
lying
about
it
strictly
speaking,
being
utf-8
data
or
we're
going
to
come
up
with
some
crazy,
complicated
name
that
satisfies
the
fact
that
it's
arbitrary
data
and
only
looking
only
interpreting
it
as
bytes
rather
than
as
char,
and
I
think
for
given
the
advanced
scenario
and
everything
else,
I'm
not
sure
that
those
are
really
concerns
that
should
exist
here.
So
yeah.
D
C
So
an
alternative-
and
maybe
maybe
this
satisfies
one
of
your
earlier-
concerns
steve.
What
if
we
had
an
api
that,
given
a
char
star
or
a
byte
star,
returns
the
char
star
or
the
byte
star
of
where
the
null
terminator
is
like.
It
takes
a
pointer
and
it
returns
a
pointer
and
it's
up
to
you
the
caller
to
do
subtraction.
E
C
C
And
from
but
yeah
create
span
from
makes
sense,
I
mean
it
matches
a
create
span.
Well,
we
we
have
create
from
pinned
array,
but
that's
create
memory,
so
never
mind.
D
40.
all
right
and
we're
then
deciding
to
punt
on
get
string
length
instead
of
make
it
return
and
right.
E
D
For
some
reason,
I
thought
that
span
did
support
full
memory,
even
in
a.
C
Yeah
there
there
is
a
separate
work
item
by
the
way,
and
this
is
what
steve
and
others
alluded
to
earlier
in
the
conversation
about
there.
There
is
consideration
for
a
native
span
that
would
have
a
new
end
for
a
length
once
that
comes
online.
If
that
comes
online,
we're
going
to
have
to
update
a
whole
slew
of
methods
in
the
framework,
including
this
one,
but
that's
a
that's
a
bridge
we
can
cross.
When
you
know
we
get
to
it.
C
D
Yeah,
I
mean,
I
guess
yes,
it'll
need
a
behavior,
which
is
probably
invalid
operation
exception.
C
A
D
G
I
also
expect
in
the
99.999
case
we
will.
We
will
av
before
then.
D
Yeah,
my
guess
would
be
invalid
operation
exception.
It's
not
super
common.
Somebody
should
get
it
it's
not.
I
mean
it
is
sort
of
an
argument
problem,
but
it's
not
something
that
could
pre-validate,
but
it
feels
like
the
method
got
into
a
state
that
it
just
can't
continue,
which
is
invalid
operation.
That's
also
fine.
Now.
A
C
C
D
C
I
think
it
was
to
make
the
jit
happier,
because
then
it
didn't
need
to
do
the
implicit
conversion
from
span
to
read
only
span
before
calling
helper
functions.
A
D
D
There
are,
there
are
benefits
to
it.
That's
I
mean
the,
but
the
question
is
just:
is
there
a
reason
we
are
willing,
like?
What's
the
reason
that
we
said,
we
need
to
create
read-only
span,
but
we're
saying
like
shrug,
let
the
implicit
conversion
happen
for
this
one.
Is
it
just?
We
think
that
this
is,
you
know,
super
much
rarer
than
creating
it
for
ft.
C
I
think
create
really
span
was
done
as
a
performance
optimization
because
I
think
at
the
time
it
was
created.
The
jit
didn't
properly
optimize
conversions
from
span
to
read
only
spam,
but
that's
I
mean
I'm
I'm
reaching
like
deep
into
the.
You
know
annals
of
my
memory
here.
So
don't
quote
me
on
that
in.
G
D
Yeah
yeah,
I
mean,
given
that
it's
easier
to
add
than
remove
only
adding
the
writable
span
version
right
now
seems
fine.
I'm
just
making
sure
that
we're
not
missing
something
obvious.
G
We
have
an
entire
year
to
come
back
and
fix
that.
A
H
C
A
Yep
awesome,
then
this
is
it
for
today
and
then
I
see
you
guys
next
week,
where
we
do
another
iteration
of
the
release.
Json
apis.