normalized.txt

and            	 nnp => and            	 nnp	:b-gpe
ascii          	 nnp => ascii          	 nnp	:b-gpe
additionally   	  rb => additionally   	  rb	:o
address        	  nn => address        	  nn	:o
alias          	 nnp => alias          	 nnp	:o
allocation     	 nnp => allocation     	 nnp	:o
also           	  rb => also           	  rb	:o
appending      	 vbg => append         	  vb	:o
applying       	 vbg => appli          	  vb	:o
arithmetic     	  jj => arithmetic     	  jj	:b-gpe
array          	  nn => array          	  nn	:o
assignability  	 nnp => assignability  	 nnp	:o
assigning      	 vbg => assign         	  vb	:o
assignments    	 nns => assignment     	  nn	:o
assume         	 nnp => assume         	 nnp	:o
backus-naur    	  jj => backus-naur    	  jj	:o
binary         	  jj => binary         	  jj	:o
blank          	 nnp => blank          	 nnp	:b-person
blocks         	 nnp => blocks         	 nnp	:b-person
boolean        	  jj => boolean        	  jj	:b-gpe
bootstrapping  	 nnp => bootstrapping  	 nnp	:o
break          	 nnp => break          	 nnp	:o
built-in       	  jj => built-in       	  jj	:o
calling        	 vbg => call           	  vb	:o
calls          	 vbz => call           	  vb	:o
camelcase      	 nnp => camelcase      	 nnp	:b-gpe
carriage       	 nnp => carriage       	 nnp	:o
cases          	 nns => case           	  nn	:o
category       	 nnp => category       	 nnp	:o
channel        	 nnp => channel        	 nnp	:o
channels       	 nnp => channels       	 nnp	:o
characters     	nnps => character      	  nn	:o
close          	 nnp => close          	 nnp	:o
closing        	 vbg => close          	  vb	:o
comments       	 nns => comment        	  nn	:o
communication  	  nn => communication  	  nn	:o
comparison     	 nnp => comparison     	 nnp	:o
comparisons    	 nns => comparison     	  nn	:o
complex        	  jj => complex        	  jj	:o
composite      	  jj => composite      	  jj	:o
computer       	 nnp => computer       	 nnp	:o
consequently   	  rb => consequently   	  rb	:o
consider       	  vb => consider       	  vb	:o
constspec      	 nnp => constspec      	 nnp	:o
constant       	  jj => constant       	  jj	:o
constants      	 nns => constant       	  nn	:o
continue       	 nnp => continue       	 nnp	:o
conversions    	 nns => conversion     	  nn	:o
converting     	 vbg => convert        	  vb	:o
current        	 nnp => current        	 nnp	:o
declarations   	 nns => declaration    	  nn	:o
defer          	 nnp => defer          	 nnp	:o
deletion       	  nn => deletion       	  nn	:o
dependency     	 nnp => dependency     	 nnp	:o
ebnf           	 nnp => ebnf           	 nnp	:b-gpe
elements       	 nns => element        	  nn	:o
embeddedfield  	 nnp => embeddedfield  	 nnp	:b-gpe
empty          	  jj => empty          	  jj	:o
errors         	nnps => error          	  nn	:o
examples       	 nns => example        	  nn	:o
executing      	 vbg => execut         	  vb	:o
execution      	  nn => execution      	  nn	:o
explicit       	 nnp => explicit       	 nnp	:b-person
exported       	 vbn => export         	  vb	:o
expression     	  nn => expression     	  nn	:o
expressions    	 nns => expression     	  nn	:o
extended       	  jj => extended       	  jj	:o
fma            	 nnp => fma            	 nnp	:o
field          	 nnp => field          	 nnp	:b-person
first          	 nnp => first          	 nnp	:o
floating-point 	  jj => floating-point 	  jj	:o
forclause      	 nnp => forclause      	 nnp	:o
form           	 nnp => form           	 nnp	:o
full           	 nnp => full           	 nnp	:o
function       	 nnp => function       	 nnp	:o
further        	  jj => further        	  jj	:o
general        	  jj => general        	  jj	:o
general        	 nnp => general        	 nnp	:o
give           	  vb => give           	  vb	:o
given          	 vbn => given          	  vb	:o
go             	 nnp => go             	 nnp	:b-gpe
go             	 nnp => go             	 nnp	:o
goto           	 nnp => goto           	 nnp	:o
graphic        	 nnp => graphic        	 nnp	:b-gpe
handling       	 vbg => handl          	  vb	:o
here           	  rb => here           	  rb	:o
hexadecimal    	 nnp => hexadecimal    	 nnp	:o
however        	  rb => however        	  rb	:o
ieee           	 nnp => ieee           	 nnp	:o
ieee-754       	  jj => ieee-754       	  jj	:o
identifierlist 	 nnp => identifierlist 	 nnp	:o
identifiers    	nnps => identifier     	  nn	:o
imaginary      	 nnp => imaginary      	 nnp	:o
implementation 	 nnp => implementation 	 nnp	:o
import         	 nnp => import         	 nnp	:o
importpath     	 nnp => importpath     	 nnp	:b-gpe
importpaths    	 nnp => importpaths    	 nnp	:o
incdec         	  jj => incdec         	  jj	:o
index          	 nnp => index          	 nnp	:b-gpe
initialization 	 nnp => initialization 	 nnp	:o
instead        	  rb => instead        	  rb	:o
integer        	 jjr => integer        	 jjr	:o
interface      	 nnp => interface      	 nnp	:o
interpreted    	 vbn => interpret      	  vb	:o
introduction   	  nn => introduction   	  nn	:o
iota           	 nnp => iota           	 nnp	:o
keywords       	  vb => keywords       	  vb	:o
label          	 nnp => label          	 nnp	:b-person
labeled        	 vbn => label          	  vb	:o
labels         	 nnp => labels         	 nnp	:b-gpe
length         	 nnp => length         	 nnp	:b-person
letter         	 nnp => letter         	 nnp	:o
letters        	 nns => letter         	  nn	:o
lexical        	  jj => lexical        	  jj	:o
line           	 nnp => line           	 nnp	:o
literal        	  jj => literal        	  jj	:o
literaltype    	 nnp => literaltype    	 nnp	:b-gpe
ll             	 nnp => ll             	 nnp	:b-gpe
lm             	 nnp => lm             	 nnp	:b-gpe
lo             	 nnp => lo             	 nnp	:o
logical        	  jj => logical        	  jj	:o
loosely        	  rb => loosely        	  rb	:o
lower-case     	  jj => lower-case     	  jj	:o
lt             	 nnp => lt             	 nnp	:b-gpe
lu             	 nnp => lu             	 nnp	:o
making         	 vbg => make           	  vb	:o
manipulating   	 vbg => manipul        	  vb	:o
map            	 nnp => map            	 nnp	:o
method         	 nnp => method         	 nnp	:b-gpe
more           	 rbr => more           	 rbr	:o
moreover       	  rb => moreover       	  rb	:o
multiple       	 nnp => multiple       	 nnp	:o
multiplication 	  nn => multiplication 	  nn	:o
nul            	 nnp => nul            	 nnp	:b-gpe
nan            	 nnp => nan            	 nnp	:o
nd             	 nnp => nd             	 nnp	:o
next           	  jj => next           	  jj	:o
non-exported   	  jj => non-exported   	  jj	:o
non-terminals  	 nns => non-terminal   	  nn	:o
notation       	 nnp => notation       	 nnp	:o
note           	  nn => note           	  nn	:o
number         	 nnp => number         	 nnp	:o
numeric        	 nnp => numeric        	 nnp	:o
or             	 nnp => or             	 nnp	:o
octal          	  jj => octal          	  jj	:o
omitted        	 vbn => omit           	  vb	:o
omitting       	 vbg => omit           	  vb	:o
only           	  rb => only           	  rb	:o
operands       	 nns => operand        	  nn	:o
operator       	 nnp => operator       	 nnp	:o
operators      	nnps => operator       	  nn	:o
order          	  nn => order          	  nn	:o
others         	 nns => other          	  nn	:o
otherwise      	  rb => otherwise      	  rb	:o
otherwise      	  vb => otherwise      	  vb	:o
overflow       	 nnp => overflow       	 nnp	:b-person
package        	  vb => package        	  vb	:o
packagename    	 nnp => packagename    	 nnp	:b-gpe
packages       	 nns => package        	  nn	:o
parameter      	 nnp => parameter      	 nnp	:b-person
passing        	 vbg => pass           	  vb	:o
pointer        	  nn => pointer        	  nn	:o
pointers       	 nns => pointer        	  nn	:o
predeclared    	 vbd => predeclar      	  vb	:o
primary        	  jj => primary        	  jj	:o
productions    	 nns => production     	  nn	:o
program        	 nnp => program        	 nnp	:o
programs       	 nns => program        	  nn	:o
promoted       	 vbn => promot         	  vb	:o
properties     	 nns => property       	  nn	:o
qualified      	 vbn => qualifi        	  vb	:o
raw            	 nnp => raw            	 nnp	:o
receive        	 nnp => receive        	 nnp	:o
receiving      	 vbg => receiv         	  vb	:o
recvexpr       	 nnp => recvexpr       	 nnp	:b-gpe
recvstmt       	 nnp => recvstmt       	 nnp	:o
redeclaration  	  nn => redeclaration  	  nn	:o
regardless     	 nnp => regardless     	 nnp	:o
represent      	  jj => represent      	  jj	:o
representability	 nnp => representability	 nnp	:o
return         	 nnp => return         	 nnp	:o
round          	 nnp => round          	 nnp	:o
rounding       	 vbg => round          	  vb	:o
run-time       	  jj => run-time       	  jj	:o
rune           	 nnp => rune           	 nnp	:o
second         	 nnp => second         	 nnp	:o
section        	  nn => section        	  nn	:o
see            	 nnp => see            	 nnp	:b-person
select         	  jj => select         	  jj	:o
selectors      	 nns => selector       	  nn	:o
semicolons     	nnps => semicolon      	  nn	:o
send           	  jj => send           	  jj	:o
sending        	 vbg => send           	  vb	:o
several        	  jj => several        	  jj	:o
shifts         	 nns => shift          	  nn	:o
short          	 nnp => short          	 nnp	:o
shortvardecl   	 nnp => shortvardecl   	 nnp	:o
similarly      	  rb => similarly      	  rb	:o
simple         	  jj => simple         	  jj	:o
size           	 nnp => size           	 nnp	:b-person
slice          	 nnp => slice          	 nnp	:o
source         	 nnp => source         	 nnp	:b-gpe
specific       	  jj => specific       	  jj	:o
specifically   	  rb => specifically   	  rb	:o
standard       	 nnp => standard       	 nnp	:o
statements     	 nns => statement      	  nn	:o
string         	 vbg => string         	  vb	:o
strings        	 nns => string         	  nn	:o
struct         	  nn => struct         	  nn	:o
structured     	 nnp => structured     	 nnp	:o
such           	  jj => such           	  jj	:o
suppose        	  vb => suppose        	  vb	:o
switch         	 nnp => switch         	 nnp	:b-gpe
switch         	  vb => switch         	  vb	:o
system         	  nn => system         	  nn	:o
taking         	 vbg => take           	  vb	:o
terminating    	 vbg => termin         	  vb	:o
there          	  ex => there          	  ex	:o
thus           	 nnp => thus           	 nnp	:o
together       	  rb => together       	  rb	:o
tokens         	  jj => tokens         	  jj	:b-gpe
type           	 nnp => type           	 nnp	:b-person
typename       	  nn => typename       	  nn	:o
typename       	 nnp => typename       	 nnp	:b-gpe
typespec       	 nnp => typespec       	 nnp	:b-gpe
typeswitchcase 	 nnp => typeswitchcase 	 nnp	:o
typeswitchguard	 nnp => typeswitchguard	 nnp	:b-gpe
types          	 vbz => type           	  vb	:o
utf-8          	  jj => utf-8          	  jj	:o
utf-8          	 nnp => utf-8          	 nnp	:b-gpe
utf-8-encoded  	  jj => utf-8-encoded  	  jj	:o
utf-8-encoded  	 nnp => utf-8-encoded  	 nnp	:o
unary          	 nnp => unary          	 nnp	:o
unicode        	 nnp => unicode        	 nnp	:b-gpe
uniqueness     	 nnp => uniqueness     	 nnp	:o
untyped        	  jj => untyped        	  jj	:o
values         	 nns => value          	  nn	:o
varspec        	 nnp => varspec        	 nnp	:b-gpe
variable       	  jj => variable       	  jj	:o
variables      	 nns => variable       	  nn	:o
white          	 nnp => white          	 nnp	:b-person
absent         	  jj => absent         	  jj	:o
accent         	  nn => accent         	  nn	:o
accented       	  jj => accented       	  jj	:o
accept         	  vb => accept         	  vb	:o
accepts        	 vbz => accept         	  vb	:o
access         	  nn => access         	  nn	:o
accessed       	 vbn => access         	  vb	:o
accesses       	 vbz => access         	  vb	:o
accessible     	  jj => accessible     	  jj	:o
accommodate    	  vb => accommodate    	  vb	:o
according      	 vbg => accord         	  vb	:o
accurately     	  rb => accurately     	  rb	:o
act            	 vbp => act            	  vb	:o
acts           	 vbz => act            	  vb	:o
actual         	  jj => actual         	  jj	:o
add            	  vb => add            	  vb	:o
added          	 vbn => ad             	  vb	:o
adding         	 vbg => ad             	  vb	:o
addition       	  nn => addition       	  nn	:o
additional     	  jj => additional     	  jj	:o
additionally   	  rb => additionally   	  rb	:o
address        	  nn => address        	  nn	:o
addressability 	  nn => addressability 	  nn	:o
addressable    	  jj => addressable    	  jj	:o
addressed      	 vbn => address        	  vb	:o
addresses      	 nns => address        	  nn	:o
advance        	  vb => advance        	  vb	:o
advances       	 nns => advance        	  nn	:o
affect         	 vbp => affect         	  vb	:o
alias          	  nn => alias          	  nn	:o
aligned        	 vbn => align          	  vb	:o
alignment      	  nn => alignment      	  nn	:o
all            	 pdt => all            	 pdt	:o
allocated      	 vbn => alloc          	  vb	:o
allocates      	 vbz => alloc          	  vb	:o
allocating     	 vbg => alloc          	  vb	:o
allow          	 vbp => allow          	  vb	:o
allowed        	 vbn => allow          	  vb	:o
allowing       	 vbg => allow          	  vb	:o
allows         	 vbz => allow          	  vb	:o
alone          	  rb => alone          	  rb	:o
already        	  rb => already        	  rb	:o
also           	  rb => also           	  rb	:o
alternatives   	 nns => alternative    	  nn	:o
always         	  rb => always         	  rb	:o
ambiguity      	  nn => ambiguity      	  nn	:o
analysis       	  nn => analysis       	  nn	:o
analyzed       	 vbn => analyz         	  vb	:o
anew           	  rb => anew           	  rb	:o
annotated      	 vbn => annot          	  vb	:o
anonymous      	  jj => anonymous      	  jj	:o
anywhere       	  rb => anywhere       	  rb	:o
appear         	 vbp => appear         	  vb	:o
appears        	 vbz => appear         	  vb	:o
appends        	 vbz => append         	  vb	:o
applied        	 vbd => appli          	  vb	:o
applies        	 nns => apply          	  nn	:o
apply          	  rb => apply          	  rb	:o
apply          	 vbp => appli          	  vb	:o
applying       	 vbg => appli          	  vb	:o
arbitrary      	  jj => arbitrary      	  jj	:o
architecture   	  nn => architecture   	  nn	:o
architecture-independent	  jj => architecture-independent	  jj	:o
architectures  	 vbz => architectur    	  vb	:o
argument       	  nn => argument       	  nn	:o
arguments      	 nns => argument       	  nn	:o
arises         	 nns => arise          	  nn	:o
arithmetic     	  jj => arithmetic     	  jj	:o
arithmetic     	  nn => arithmetic     	  nn	:o
array          	  nn => array          	  nn	:o
array          	  vb => array          	  vb	:o
arrays         	 nns => array          	  nn	:o
assemble       	  jj => assemble       	  jj	:o
assembly       	  nn => assembly       	  nn	:o
assertion      	  nn => assertion      	  nn	:o
assertions     	 nns => assertion      	  nn	:o
asserts        	 vbz => assert         	  vb	:o
assign         	  vb => assign         	  vb	:o
assignable     	  jj => assignable     	  jj	:o
assigned       	 vbn => assign         	  vb	:o
assigning      	 vbg => assign         	  vb	:o
assignment     	  nn => assignment     	  nn	:o
assignments    	 nns => assignment     	  nn	:o
assigns        	 vbz => assign         	  vb	:o
assist         	  vb => assist         	  vb	:o
associate      	  nn => associate      	  nn	:o
associated     	  jj => associated     	  jj	:o
associates     	 vbz => associ         	  vb	:o
associativity  	  nn => associativity  	  nn	:o
assume         	  vb => assume         	  vb	:o
assumption     	  nn => assumption     	  nn	:o
attempt        	  nn => attempt        	  nn	:o
attempting     	 vbg => attempt        	  vb	:o
attribute      	  nn => attribute      	  nn	:o
automatic      	  jj => automatic      	  jj	:o
automatically  	  rb => automatically  	  rb	:o
available      	  jj => available      	  jj	:o
avoid          	  vb => avoid          	  vb	:o
back           	  rb => back           	  rb	:o
backslash      	  jj => backslash      	  jj	:o
backslash      	  nn => backslash      	  nn	:o
backslashes    	 nns => backslash      	  nn	:o
backward       	  jj => backward       	  jj	:o
base           	  nn => base           	  nn	:o
becomes        	 vbz => becom          	  vb	:o
been           	 vbn => been           	  vb	:o
beginning      	 vbg => begin          	  vb	:o
begins         	 nns => begin          	  nn	:o
begins         	 vbz => begin          	  vb	:o
behave         	 vbp => behav          	  vb	:o
behavior       	  nn => behavior       	  nn	:o
belonging      	 vbg => belong         	  vb	:o
belongs        	 nns => belong         	  nn	:o
belongs        	 vbz => belong         	  vb	:o
bidirectional  	  jj => bidirectional  	  jj	:o
binary         	  jj => binary         	  jj	:o
bind           	 vbp => bind           	  vb	:o
binding        	  nn => binding        	  nn	:o
binding        	 vbg => bind           	  vb	:o
binds          	 vbz => bind           	  vb	:o
bit            	  nn => bit            	  nn	:o
bits           	 nns => bit            	  nn	:o
bitwise        	  nn => bitwise        	  nn	:o
blank          	  jj => blank          	  jj	:o
block          	  nn => block          	  nn	:o
blocking       	 vbg => block          	  vb	:o
blocks         	 nns => block          	  nn	:o
blocks         	 vbz => block          	  vb	:o
body           	  nn => body           	  nn	:o
boolean        	  jj => boolean        	  jj	:o
boolean        	  nn => boolean        	  nn	:o
booleans       	 nns => boolean        	  nn	:o
bootstrapping  	 vbg => bootstrap      	  vb	:o
bound          	  nn => bound          	  nn	:o
bound          	 vbn => bound          	  vb	:o
bounds         	 nns => bound          	  nn	:o
brace          	  nn => brace          	  nn	:o
brace-bound    	  jj => brace-bound    	  jj	:o
braces         	 nns => brace          	  nn	:o
brackets       	 nns => bracket        	  nn	:o
branch         	  nn => branch         	  nn	:o
branches       	 nns => branch         	  nn	:o
break          	  nn => break          	  nn	:o
breaking       	 vbg => break          	  vb	:o
broken         	 vbn => broken         	  vb	:o
buffer         	  nn => buffer         	  nn	:o
buffered       	  jj => buffered       	  jj	:o
build          	  jj => build          	  jj	:o
built-in       	  jj => built-in       	  jj	:o
byte           	  nn => byte           	  nn	:o
byte-wise      	  nn => byte-wise      	  nn	:o
bytes          	 nns => byte           	  nn	:o
calculated     	 vbn => calcul         	  vb	:o
call           	  nn => call           	  nn	:o
callable       	  jj => callable       	  jj	:o
called         	 vbd => call           	  vb	:o
called         	 vbn => call           	  vb	:o
caller         	  nn => caller         	  nn	:o
callers        	 nns => caller         	  nn	:o
calling        	 vbg => call           	  vb	:o
calls          	 nns => call           	  nn	:o
calls          	 vbz => call           	  vb	:o
cannot         	 vbp => cannot         	  vb	:o
canonicalized  	 vbn => canonic        	  vb	:o
capacity       	  nn => capacity       	  nn	:o
carriage       	  nn => carriage       	  nn	:o
carried        	 vbn => carri          	  vb	:o
case           	  nn => case           	  nn	:o
cases          	 nns => case           	  nn	:o
categories     	 nns => category       	  nn	:o
category       	  nn => category       	  nn	:o
cause          	  vb => cause          	  vb	:o
causes         	 vbz => caus           	  vb	:o
causing        	 vbg => caus           	  vb	:o
certain        	  jj => certain        	  jj	:o
change         	 vbp => chang          	  vb	:o
changes        	 vbz => chang          	  vb	:o
channel        	  nn => channel        	  nn	:o
channels       	 nns => channel        	  nn	:o
channels       	  vb => channels       	  vb	:o
character      	  nn => character      	  nn	:o
characters     	 nns => character      	  nn	:o
choice         	  nn => choice         	  nn	:o
chooses        	 vbz => choos          	  vb	:o
chosen         	 vbn => chosen         	  vb	:o
circumstances  	 nns => circumstance   	  nn	:o
class          	  nn => class          	  nn	:o
classes        	 nns => class          	  nn	:o
clause         	  nn => clause         	  nn	:o
clauses        	 nns => clause         	  nn	:o
closed         	  jj => closed         	  jj	:o
closed         	 vbn => close          	  vb	:o
closing        	 vbg => close          	  vb	:o
closures       	 nns => closure        	  nn	:o
code           	  nn => code           	  nn	:o
collectively   	  rb => collectively   	  rb	:o
combine        	  vb => combine        	  vb	:o
combining      	 vbg => combin         	  vb	:o
come           	  vb => come           	  vb	:o
comment        	  nn => comment        	  nn	:o
comments       	 nns => comment        	  nn	:o
common         	  jj => common         	  jj	:o
communicate    	  vb => communicate    	  vb	:o
communication  	  nn => communication  	  nn	:o
communications 	 nns => communication  	  nn	:o
compact        	  jj => compact        	  jj	:o
comparable     	  jj => comparable     	  jj	:o
compare        	 vbp => compar         	  vb	:o
compared       	 vbn => compar         	  vb	:o
compares       	 vbz => compar         	  vb	:o
comparing      	 vbg => compar         	  vb	:o
comparison     	  nn => comparison     	  nn	:o
comparisons    	 nns => comparison     	  nn	:o
compatibility  	  nn => compatibility  	  nn	:o
compile        	  jj => compile        	  jj	:o
compile-time   	  jj => compile-time   	  jj	:o
compiled       	  jj => compiled       	  jj	:o
compiler       	  nn => compiler       	  nn	:o
compilers      	 nns => compiler       	  nn	:o
complement     	  nn => complement     	  nn	:o
complete       	  jj => complete       	  jj	:o
complete       	  vb => complete       	  vb	:o
completeness   	  nn => completeness   	  nn	:o
completes      	 vbz => complet        	  vb	:o
complex        	  jj => complex        	  jj	:o
component      	  nn => component      	  nn	:o
components     	 nns => component      	  nn	:o
composed       	 vbn => compos         	  vb	:o
composes       	 vbz => compos         	  vb	:o
composite      	  jj => composite      	  jj	:o
comprising     	 vbg => compris        	  vb	:o
computation    	  nn => computation    	  nn	:o
computed       	 vbn => comput         	  vb	:o
computes       	 vbz => comput         	  vb	:o
computing      	 vbg => comput         	  vb	:o
concatenated   	 vbn => concaten       	  vb	:o
concatenating  	 vbg => concaten       	  vb	:o
concatenation  	  nn => concatenation  	  nn	:o
concrete       	  jj => concrete       	  jj	:o
concurrent     	  jj => concurrent     	  jj	:o
concurrently   	  rb => concurrently   	  rb	:o
condition      	  nn => condition      	  nn	:o
conditional    	  jj => conditional    	  jj	:o
conditionally  	  rb => conditionally  	  rb	:o
conditions     	 nns => condition      	  nn	:o
conflict       	  vb => conflict       	  vb	:o
consequence    	  nn => consequence    	  nn	:o
consider       	  vb => consider       	  vb	:o
considerations 	 nns => consideration  	  nn	:o
considered     	 vbn => consid         	  vb	:o
consist        	 vbp => consist        	  vb	:o
consisting     	 vbg => consist        	  vb	:o
consists       	 vbz => consist        	  vb	:o
constant       	  jj => constant       	  jj	:o
constant       	  nn => constant       	  nn	:o
constants      	 nns => constant       	  nn	:o
constituents   	 nns => constituent    	  nn	:o
constrained    	 vbn => constrain      	  vb	:o
constraint     	  nn => constraint     	  nn	:o
construct      	  nn => construct      	  nn	:o
constructed    	 vbn => construct      	  vb	:o
construction   	  nn => construction   	  nn	:o
constructs     	 vbz => construct      	  vb	:o
contain        	  vb => contain        	  vb	:o
containing     	 vbg => contain        	  vb	:o
contains       	 vbz => contain        	  vb	:o
contents       	 nns => content        	  nn	:o
context        	  nn => context        	  nn	:o
contexts       	 nns => context        	  nn	:o
contiguous     	  jj => contiguous     	  jj	:o
continue       	  nn => continue       	  nn	:o
continue       	 vbp => continu        	  vb	:o
contrast       	  nn => contrast       	  nn	:o
control        	  nn => control        	  nn	:o
control        	 vbp => control        	  vb	:o
controlled     	 vbn => control        	  vb	:o
controls       	 vbz => control        	  vb	:o
convenience    	  nn => convenience    	  nn	:o
conventional   	  jj => conventional   	  jj	:o
conversion     	  nn => conversion     	  nn	:o
conversions    	 nns => conversion     	  nn	:o
convert        	  vb => convert        	  vb	:o
converted      	 vbn => convert        	  vb	:o
converting     	 vbg => convert        	  vb	:o
copied         	 vbn => copi           	  vb	:o
copies         	 vbz => copi           	  vb	:o
copy           	  nn => copy           	  nn	:o
copying        	 vbg => copi           	  vb	:o
correct        	  jj => correct        	  jj	:o
correspond     	  nn => correspond     	  nn	:o
corresponding  	  jj => corresponding  	  jj	:o
cost           	  nn => cost           	  nn	:o
count          	  nn => count          	  nn	:o
create         	  vb => create         	  vb	:o
created        	 vbn => creat          	  vb	:o
creates        	 vbz => creat          	  vb	:o
creation       	  nn => creation       	  nn	:o
curly          	  rb => curly          	  rb	:o
current        	  jj => current        	  jj	:o
cycles         	 nns => cycle          	  nn	:o
cyclic         	  jj => cyclic         	  jj	:o
data           	 nns => data           	 nns	:o
decimal        	  jj => decimal        	  jj	:o
declaration    	  nn => declaration    	  nn	:o
declarations   	 nns => declaration    	  nn	:o
declare        	  vb => declare        	  vb	:o
declared       	 vbn => declar         	  vb	:o
declares       	 vbz => declar         	  vb	:o
decrement      	  jj => decrement      	  jj	:o
default        	  nn => default        	  nn	:o
defaults       	 vbz => default        	  vb	:o
defer          	  nn => defer          	  nn	:o
deferred       	  jj => deferred       	  jj	:o
deferred       	 vbn => defer          	  vb	:o
defers         	 vbz => defer          	  vb	:o
define         	  vb => define         	  vb	:o
defined        	 vbn => defin          	  vb	:o
defines        	 vbz => defin          	  vb	:o
defining       	 vbg => defin          	  vb	:o
definition     	  nn => definition     	  nn	:o
definitions    	 nns => definition     	  nn	:o
delivered      	 vbn => deliv          	  vb	:o
denote         	 vbp => denot          	  vb	:o
denoted        	 vbn => denot          	  vb	:o
denotes        	 vbz => denot          	  vb	:o
denoting       	 vbg => denot          	  vb	:o
dependencies   	 nns => dependency     	  nn	:o
dependency     	  nn => dependency     	  nn	:o
depending      	 vbg => depend         	  vb	:o
depends        	 vbz => depend         	  vb	:o
depth          	  nn => depth          	  nn	:o
dereference    	  vb => dereference    	  vb	:o
dereferenced   	 vbn => dereferenc     	  vb	:o
derive         	  vb => derive         	  vb	:o
derived        	 vbn => deriv          	  vb	:o
described      	 vbn => describ        	  vb	:o
describes      	 vbz => describ        	  vb	:o
descriptor     	  nn => descriptor     	  nn	:o
designed       	 vbn => design         	  vb	:o
destination    	  nn => destination    	  nn	:o
detail         	  nn => detail         	  nn	:o
determine      	  vb => determine      	  vb	:o
determined     	 vbn => determin       	  vb	:o
determines     	 vbz => determin       	  vb	:o
deterministically	  rb => deterministically	  rb	:o
development    	  nn => development    	  nn	:o
differ         	  vb => differ         	  vb	:o
different      	  jj => different      	  jj	:o
differently    	  rb => differently    	  rb	:o
differs        	 nns => differ         	  nn	:o
digits         	 nns => digit          	  nn	:o
direct         	  vb => direct         	  vb	:o
direction      	  nn => direction      	  nn	:o
directly       	  rb => directly       	  rb	:o
directory      	  nn => directory      	  nn	:o
disallow       	  vb => disallow       	  vb	:o
disallowed     	 vbn => disallow       	  vb	:o
disassemble    	  jj => disassemble    	  jj	:o
discard        	  vb => discard        	  vb	:o
discarded      	 vbn => discard        	  vb	:o
discovered     	 vbn => discov         	  vb	:o
discussed      	 vbn => discuss        	  vb	:o
discussion     	  nn => discussion     	  nn	:o
distinct       	  jj => distinct       	  jj	:o
divided        	 vbn => divid          	  vb	:o
dividend       	  nn => dividend       	  nn	:o
division       	  nn => division       	  nn	:o
divisor        	  nn => divisor        	  nn	:o
do             	 vbp => do             	  vb	:o
document       	  nn => document       	  nn	:o
documentation  	  nn => documentation  	  nn	:o
documented     	 vbn => document       	  vb	:o
documents      	 nns => document       	  nn	:o
does           	 vbz => doe            	  vb	:o
done           	 vbn => done           	  vb	:o
double         	  jj => double         	  jj	:o
due            	  jj => due            	  jj	:o
duplicate      	  nn => duplicate      	  nn	:o
dynamic        	  jj => dynamic        	  jj	:o
dynamically    	  rb => dynamically    	  rb	:o
earlier        	 rbr => earlier        	 rbr	:o
earliest       	 jjs => earli          	  jj	:o
easy           	  jj => easy           	  jj	:o
effect         	  nn => effect         	  nn	:o
effects        	 nns => effect         	  nn	:o
efficient      	  jj => efficient      	  jj	:o
element        	  nn => element        	  nn	:o
elementary     	  jj => elementary     	  jj	:o
elements       	 nns => element        	  nn	:o
elide          	  vb => elide          	  vb	:o
elided         	 vbn => elid           	  vb	:o
ellipsis       	  nn => ellipsis       	  nn	:o
else           	  rb => else           	  rb	:o
elsewhere      	  rb => elsewhere      	  rb	:o
embed          	  vb => embed          	  vb	:o
embedded       	  jj => embedded       	  jj	:o
embedding      	 vbg => embed          	  vb	:o
embeds         	 vbz => emb            	  vb	:o
empty          	  jj => empty          	  jj	:o
empty          	  rb => empty          	  rb	:o
enables        	 vbz => enabl          	  vb	:o
enclosed       	 vbn => enclos         	  vb	:o
enclosing      	 vbg => enclos         	  vb	:o
encode         	  nn => encode         	  nn	:o
encoded        	 vbn => encod          	  vb	:o
encoding       	  nn => encoding       	  nn	:o
encompasses    	 vbz => encompass      	  vb	:o
encounters     	 vbz => encount        	  vb	:o
encouraged     	 vbn => encourag       	  vb	:o
end            	  nn => end            	  nn	:o
ends           	 vbz => end            	  vb	:o
enforces       	 vbz => enforc         	  vb	:o
enough         	  rb => enough         	  rb	:o
ensure         	  vb => ensure         	  vb	:o
entering       	 vbg => enter          	  vb	:o
entire         	  jj => entire         	  jj	:o
entirely       	  rb => entirely       	  rb	:o
entities       	 nns => entity         	  nn	:o
entity         	  nn => entity         	  nn	:o
entries        	 nns => entry          	  nn	:o
entry          	  nn => entry          	  nn	:o
enumerations   	 nns => enumeration    	  nn	:o
environments   	 nns => environment    	  nn	:o
equal          	  jj => equal          	  jj	:o
equal          	  vb => equal          	  vb	:o
equality       	  nn => equality       	  nn	:o
equals         	 vbz => equal          	  vb	:o
equivalent     	  jj => equivalent     	  jj	:o
equivalent     	  nn => equivalent     	  nn	:o
erroneous      	  jj => erroneous      	  jj	:o
erroneously    	  rb => erroneously    	  rb	:o
error          	  nn => error          	  nn	:o
errors         	 nns => error          	  nn	:o
escapes        	 nns => escape         	  nn	:o
evaluate       	 vbp => evalu          	  vb	:o
evaluated      	 vbn => evalu          	  vb	:o
evaluates      	 vbz => evalu          	  vb	:o
evaluating     	 vbg => evalu          	  vb	:o
evaluation     	  nn => evaluation     	  nn	:o
even           	  rb => even           	  rb	:o
events         	 nns => event          	  nn	:o
exact          	  jj => exact          	  jj	:o
exactly        	  rb => exactly        	  rb	:o
example        	  nn => example        	  nn	:o
examples       	 nns => example        	  nn	:o
exception      	  nn => exception      	  nn	:o
exclude        	  vb => exclude        	  vb	:o
excludes       	 vbz => exclud         	  vb	:o
execute        	  vb => execute        	  vb	:o
executed       	 vbn => execut         	  vb	:o
executes       	 nns => execute        	  nn	:o
executes       	 vbz => execut         	  vb	:o
executing      	 vbg => execut         	  vb	:o
execution      	  nn => execution      	  nn	:o
exist          	  vb => exist          	  vb	:o
existing       	 vbg => exist          	  vb	:o
exists         	 vbz => exist          	  vb	:o
exits          	 vbz => exit           	  vb	:o
exp            	  nn => exp            	  nn	:o
explicit       	  jj => explicit       	  jj	:o
explicitly     	  rb => explicitly     	  rb	:o
exploits       	 vbz => exploit        	  vb	:o
exponent       	  nn => exponent       	  nn	:o
exported       	  jj => exported       	  jj	:o
exported       	 vbn => export         	  vb	:o
exports        	 nns => export         	  nn	:o
expressed      	 vbn => express        	  vb	:o
expression     	  nn => expression     	  nn	:o
expressions    	 nns => expression     	  nn	:o
extend         	  vb => extend         	  vb	:o
extended       	  jj => extended       	  jj	:o
extended       	 vbn => extend         	  vb	:o
extent         	  nn => extent         	  nn	:o
extra          	  jj => extra          	  jj	:o
extract        	  vb => extract        	  vb	:o
facilities     	 nns => facility       	  nn	:o
factor         	  nn => factor         	  nn	:o
failure        	  nn => failure        	  nn	:o
fall           	 vbp => fall           	  vb	:o
false          	  jj => false          	  jj	:o
fewer          	 jjr => fewer          	 jjr	:o
field          	  nn => field          	  nn	:o
fields         	 nns => field          	  nn	:o
file           	  nn => file           	  nn	:o
files          	 nns => file           	  nn	:o
final          	  jj => final          	  jj	:o
finally        	  rb => finally        	  rb	:o
first-in-first-out	  jj => first-in-first-out	  jj	:o
fit            	  vb => fit            	  vb	:o
fits           	 vbz => fit            	  vb	:o
floating       	 vbg => float          	  vb	:o
floating-point 	  jj => floating-point 	  jj	:o
floating-point 	  nn => floating-point 	  nn	:o
flow           	  vb => flow           	  vb	:o
flows          	 vbz => flow           	  vb	:o
followed       	 vbn => follow         	  vb	:o
following      	 vbg => follow         	  vb	:o
follows        	 vbz => follow         	  vb	:o
forever        	  rb => forever        	  rb	:o
form           	  nn => form           	  nn	:o
formal         	  jj => formal         	  jj	:o
formats        	 nns => format         	  nn	:o
formed         	 vbn => form           	  vb	:o
forms          	 nns => form           	  nn	:o
forms          	 vbp => form           	  vb	:o
fraction       	  nn => fraction       	  nn	:o
fractional     	  jj => fractional     	  jj	:o
full           	  jj => full           	  jj	:o
fully          	  rb => fully          	  rb	:o
function-local 	  jj => function-local 	  jj	:o
functionality  	  nn => functionality  	  nn	:o
functions      	 nns => function       	  nn	:o
functions—happens	 nns => functions—happen	  nn	:o
further        	 rbr => further        	 rbr	:o
fused          	  jj => fused          	  jj	:o
fused          	 vbn => fuse           	  vb	:o
fusion         	  nn => fusion         	  nn	:o
garbage-collected	  jj => garbage-collected	  jj	:o
general        	  jj => general        	  jj	:o
general-purpose	  jj => general-purpose	  jj	:o
generated      	 vbn => generat        	  vb	:o
generates      	 vbz => generat        	  vb	:o
generator      	  nn => generator      	  nn	:o
get            	 vbp => get            	  vb	:o
given          	 vbn => given          	  vb	:o
gives          	 vbz => give           	  vb	:o
goroutine      	  nn => goroutine      	  nn	:o
goroutines     	 nns => goroutine      	  nn	:o
goto           	  nn => goto           	  nn	:o
grammar        	  nn => grammar        	  nn	:o
greater        	 jjr => greater        	 jjr	:o
group          	  nn => group          	  nn	:o
grow           	  vb => grow           	  vb	:o
guaranteed     	 vbn => guarante       	  vb	:o
guarantees     	 nns => guarantee      	  nn	:o
guard          	  nn => guard          	  nn	:o
halves         	 nns => half           	  nn	:o
hand           	  nn => hand           	  nn	:o
handling       	 vbg => handl          	  vb	:o
happen         	  vb => happen         	  vb	:o
have           	  vb => have           	  vb	:o
hexadecimal    	  jj => hexadecimal    	  jj	:o
hexadecimal    	  nn => hexadecimal    	  nn	:o
hidden         	  jj => hidden         	  jj	:o
hierarchy      	  nn => hierarchy      	  nn	:o
high           	  jj => high           	  jj	:o
higher-dimensional	  jj => higher-dimensional	  jj	:o
highest        	 jjs => high           	  jj	:o
hint           	  nn => hint           	  nn	:o
hold           	  vb => hold           	  vb	:o
holding        	 vbg => hold           	  vb	:o
holds          	 vbz => hold           	  vb	:o
horizontal     	  jj => horizontal     	  jj	:o
however        	  rb => however        	  rb	:o
hypothetical   	  jj => hypothetical   	  jj	:o
identical      	  jj => identical      	  jj	:o
identified     	 vbn => identifi       	  vb	:o
identifier     	  nn => identifier     	  nn	:o
identifiers    	 nns => identifier     	  nn	:o
identify       	  vb => identify       	  vb	:o
identifying    	 vbg => identifi       	  vb	:o
identity       	  nn => identity       	  nn	:o
idiomatic      	  jj => idiomatic      	  jj	:o
ignore         	  vb => ignore         	  vb	:o
ignored        	 vbn => ignor          	  vb	:o
ignoring       	 vbg => ignor          	  vb	:o
illegal        	  jj => illegal        	  jj	:o
illustrates    	 vbz => illustr        	  vb	:o
imaginary      	  jj => imaginary      	  jj	:o
immaterial     	  jj => immaterial     	  jj	:o
immediately    	  rb => immediately    	  rb	:o
immutable      	  jj => immutable      	  jj	:o
implement      	  vb => implement      	  vb	:o
implementation 	  nn => implementation 	  nn	:o
implementation-defined	  jj => implementation-defined	  jj	:o
implementation-dependent	  jj => implementation-dependent	  jj	:o
implementation-specific	  jj => implementation-specific	  jj	:o
implementations	 nns => implementation 	  nn	:o
implemented    	 vbd => implement      	  vb	:o
implements     	 vbz => implement      	  vb	:o
implicit       	  jj => implicit       	  jj	:o
implicit       	  nn => implicit       	  nn	:o
implicitly     	  rb => implicitly     	  rb	:o
implied        	 vbn => impli          	  vb	:o
import         	  nn => import         	  nn	:o
imported       	 vbn => import         	  vb	:o
importing      	  nn => importing      	  nn	:o
imports        	 nns => import         	  nn	:o
imports        	 vbz => import         	  vb	:o
impossible     	  jj => impossible     	  jj	:o
include        	  vb => include        	  vb	:o
included       	 vbn => includ         	  vb	:o
includes       	 vbz => includ         	  vb	:o
including      	 vbg => includ         	  vb	:o
inclusive      	  jj => inclusive      	  jj	:o
incoming       	  nn => incoming       	  nn	:o
increasing     	 vbg => increas        	  vb	:o
increment      	  nn => increment      	  nn	:o
incur          	  vb => incur          	  vb	:o
independent    	  jj => independent    	  jj	:o
independently  	  rb => independently  	  rb	:o
index          	  nn => index          	  nn	:o
indexed        	 vbn => index          	  vb	:o
indexing       	  nn => indexing       	  nn	:o
indicate       	  vb => indicate       	  vb	:o
indication     	  nn => indication     	  nn	:o
indices        	 nns => index          	  nn	:o
indirection    	  nn => indirection    	  nn	:o
indirections   	 nns => indirection    	  nn	:o
indirectly     	  rb => indirectly     	  rb	:o
indirects      	 vbz => indirect       	  vb	:o
individual     	  jj => individual     	  jj	:o
individually   	  rb => individually   	  rb	:o
infinite       	  jj => infinite       	  jj	:o
infinity       	  nn => infinity       	  nn	:o
influence      	  nn => influence      	  nn	:o
informally     	  rb => informally     	  rb	:o
information    	  nn => information    	  nn	:o
inhabit        	  nn => inhabit        	  nn	:o
inherit        	  vb => inherit        	  vb	:o
init           	  nn => init           	  nn	:o
initial        	  jj => initial        	  jj	:o
initialization 	  nn => initialization 	  nn	:o
initialization—variable	  jj => initialization—variable	  jj	:o
initialize     	  vb => initialize     	  vb	:o
initialized    	 vbn => initi          	  vb	:o
initializer    	  jj => initializer    	  jj	:o
initializers   	 nns => initializer    	  nn	:o
initializes    	 vbz => initi          	  vb	:o
initializing   	 vbg => initi          	  vb	:o
inner          	  jj => inner          	  jj	:o
innermost      	  nn => innermost      	  nn	:o
input          	  nn => input          	  nn	:o
inserted       	 vbn => insert         	  vb	:o
insertion      	  nn => insertion      	  nn	:o
installed      	 vbd => instal         	  vb	:o
instance       	  nn => instance       	  nn	:o
instead        	  rb => instead        	  rb	:o
instruction    	  nn => instruction    	  nn	:o
instructions   	 nns => instruction    	  nn	:o
int            	  nn => int            	  nn	:o
integer        	  jj => integer        	  jj	:o
integer        	  nn => integer        	  nn	:o
integers       	 nns => integer        	  nn	:o
integral       	  jj => integral       	  jj	:o
integrated     	  jj => integrated     	  jj	:o
interface      	  nn => interface      	  nn	:o
interface-valued	  jj => interface-valued	  jj	:o
interfaces     	 nns => interface      	  nn	:o
intermediate   	  jj => intermediate   	  jj	:o
internal       	  jj => internal       	  jj	:o
interpretation 	  nn => interpretation 	  nn	:o
interpreted    	 vbn => interpret      	  vb	:o
introduce      	  vb => introduce      	  vb	:o
introduced     	 vbn => introduc       	  vb	:o
introducing    	 vbg => introduc       	  vb	:o
invalid        	  jj => invalid        	  jj	:o
inverse        	  nn => inverse        	  nn	:o
invocation     	  nn => invocation     	  nn	:o
invocations    	 nns => invocation     	  nn	:o
invoke         	  vb => invoke         	  vb	:o
invoked        	 vbn => invok          	  vb	:o
invokes        	 vbz => invok          	  vb	:o
invoking       	 vbg => invok          	  vb	:o
involves       	 vbz => involv         	  vb	:o
involving      	 vbg => involv         	  vb	:o
iota           	  nn => iota           	  nn	:o
irrelevant     	  jj => irrelevant     	  jj	:o
irrespective   	  nn => irrespective   	  nn	:o
issues         	 nns => issue          	  nn	:o
item           	  nn => item           	  nn	:o
items          	 nns => item           	  nn	:o
iterates       	 vbz => iter           	  vb	:o
iteration      	  nn => iteration      	  nn	:o
iterations     	 nns => iteration      	  nn	:o
jump           	  nn => jump           	  nn	:o
just           	  rb => just           	  rb	:o
key            	  jj => key            	  jj	:o
key            	  nn => key            	  nn	:o
keys           	 nns => key            	  nn	:o
keyword        	  nn => keyword        	  nn	:o
keywords       	 nns => keyword        	  nn	:o
kind           	  nn => kind           	  nn	:o
kinds          	 nns => kind           	  nn	:o
known          	 vbn => known          	  vb	:o
label          	  nn => label          	  nn	:o
labeled        	  jj => labeled        	  jj	:o
labeled        	 vbn => label          	  vb	:o
labeling       	 vbg => label          	  vb	:o
labels         	 nns => label          	  nn	:o
language       	  nn => language       	  nn	:o
large          	  jj => large          	  jj	:o
larger         	 jjr => larger         	 jjr	:o
largest        	 jjs => larg           	  jj	:o
last           	  jj => last           	  jj	:o
later          	  rb => later          	  rb	:o
launch         	  vb => launch         	  vb	:o
leading        	 vbg => lead           	  vb	:o
least          	 jjs => least          	 jjs	:o
left           	  nn => left           	  nn	:o
left-          	  jj => left-          	  jj	:o
left-hand      	  jj => left-hand      	  jj	:o
left-to-right  	  jj => left-to-right  	  jj	:o
leftmost       	  nn => leftmost       	  nn	:o
legal          	  jj => legal          	  jj	:o
legally        	  rb => legally        	  rb	:o
length         	  nn => length         	  nn	:o
lengths        	 nns => length         	  nn	:o
less           	 jjr => less           	 jjr	:o
letter         	  nn => letter         	  nn	:o
letters        	 nns => letter         	  nn	:o
level          	  nn => level          	  nn	:o
levels         	 nns => level          	  nn	:o
lexical        	  jj => lexical        	  jj	:o
lexically      	  rb => lexically      	  rb	:o
light-weight   	  jj => light-weight   	  jj	:o
limit          	  nn => limit          	  nn	:o
limited        	  jj => limited        	  jj	:o
limits         	 nns => limit          	  nn	:o
line           	  nn => line           	  nn	:o
linguistic     	  jj => linguistic     	  jj	:o
linking        	 vbg => link           	  vb	:o
list           	  nn => list           	  nn	:o
listed         	 vbn => list           	  vb	:o
listing        	 vbg => list           	  vb	:o
lists          	 nns => list           	  nn	:o
literal        	  jj => literal        	  jj	:o
literal        	  nn => literal        	  nn	:o
literally      	  rb => literally      	  rb	:o
literals       	 nns => literal        	  nn	:o
local          	  jj => local          	  jj	:o
location       	  nn => location       	  nn	:o
logical        	  jj => logical        	  jj	:o
long           	  rb => long           	  rb	:o
longest        	 jjs => long           	  jj	:o
looks          	 vbz => look           	  vb	:o
loop           	  nn => loop           	  nn	:o
low            	  jj => low            	  jj	:o
low-level      	  jj => low-level      	  jj	:o
lower          	 jjr => lower          	 jjr	:o
lower-case     	  jj => lower-case     	  jj	:o
made           	 vbn => made           	  vb	:o
main           	  jj => main           	  jj	:o
make           	  vb => make           	  vb	:o
manage         	  vb => manage         	  vb	:o
management     	  nn => management     	  nn	:o
mantissa       	  nn => mantissa       	  nn	:o
manual         	  nn => manual         	  nn	:o
manually       	  rb => manually       	  rb	:o
map            	  nn => map            	  nn	:o
maps           	 nns => map            	  nn	:o
mark           	  nn => mark           	  nn	:o
marked         	 vbn => mark           	  vb	:o
marking        	 vbg => mark           	  vb	:o
mask           	  nn => mask           	  nn	:o
match          	  vb => match          	  vb	:o
match          	 vbp => match          	  vb	:o
matches        	 nns => match          	  nn	:o
matching       	 vbg => match          	  vb	:o
maximum        	  jj => maximum        	  jj	:o
meaning        	  nn => meaning        	  nn	:o
measure        	  nn => measure        	  nn	:o
mechanism      	  nn => mechanism      	  nn	:o
memory         	  nn => memory         	  nn	:o
methods        	 nns => method         	  nn	:o
mind           	  nn => mind           	  nn	:o
minimal        	  jj => minimal        	  jj	:o
minimum        	  nn => minimum        	  nn	:o
missing        	  jj => missing        	  jj	:o
mixed          	 vbn => mix            	  vb	:o
modify         	  vb => modify         	  vb	:o
modulo         	  jj => modulo         	  jj	:o
moment         	  nn => moment         	  nn	:o
more           	 jjr => more           	 jjr	:o
most           	 jjs => most           	 jjs	:o
multi-byte     	  nn => multi-byte     	  nn	:o
multi-character	  jj => multi-character	  jj	:o
multi-dimensional	  jj => multi-dimensional	  jj	:o
multi-valued   	  jj => multi-valued   	  jj	:o
multi-variable 	  jj => multi-variable 	  jj	:o
multi-way      	  jj => multi-way      	  jj	:o
multiple       	  nn => multiple       	  nn	:o
multiplied     	 vbn => multipli       	  vb	:o
multiply       	  nn => multiply       	  nn	:o
n-bit          	  jj => n-bit          	  jj	:o
named          	 vbn => name           	  vb	:o
names          	 nns => name           	  nn	:o
names          	 vbz => name           	  vb	:o
nearest        	 jjs => near           	  jj	:o
necessary      	  jj => necessary      	  jj	:o
negation       	  nn => negation       	  nn	:o
negative       	  jj => negative       	  jj	:o
nest           	 jjs => n              	  jj	:o
nested         	  jj => nested         	  jj	:o
never          	  rb => never          	  rb	:o
new            	  jj => new            	  jj	:o
newline        	  jj => newline        	  jj	:o
newline        	  nn => newline        	  nn	:o
newlines       	 nns => newline        	  nn	:o
next           	  jj => next           	  jj	:o
nil            	  jj => nil            	  jj	:o
nn             	  jj => nn             	  jj	:o
nnn            	  jj => nnn            	  jj	:o
no-op          	  jj => no-op          	  jj	:o
non-           	  jj => non-           	  jj	:o
non-blank      	  jj => non-blank      	  jj	:o
non-complex    	  jj => non-complex    	  jj	:o
non-constant   	  jj => non-constant   	  jj	:o
non-constants  	 nns => non-constant   	  nn	:o
non-decimal    	  jj => non-decimal    	  jj	:o
non-empty      	  jj => non-empty      	  jj	:o
non-exported   	  jj => non-exported   	  jj	:o
non-interface  	  jj => non-interface  	  jj	:o
non-interface  	  nn => non-interface  	  nn	:o
non-negative   	  jj => non-negative   	  jj	:o
non-variadic   	  jj => non-variadic   	  jj	:o
normal         	  jj => normal         	  jj	:o
normally       	  rb => normally       	  rb	:o
not-a-number   	  jj => not-a-number   	  jj	:o
notation       	  nn => notation       	  nn	:o
nothing        	  nn => nothing        	  nn	:o
nth            	  jj => nth            	  jj	:o
number         	  nn => number         	  nn	:o
numbered       	  jj => numbered       	  jj	:o
numbers        	 nns => number         	  nn	:o
numeric        	  jj => numeric        	  jj	:o
objects        	 nns => object         	  nn	:o
obtained       	 vbn => obtain         	  vb	:o
occupy         	  vb => occupy         	  vb	:o
occur          	  vb => occur          	  vb	:o
occurs         	  nn => occurs         	  nn	:o
occurs         	 nns => occur          	  nn	:o
octal          	  jj => octal          	  jj	:o
octal          	  nn => octal          	  nn	:o
offset         	  nn => offset         	  nn	:o
omit           	  vb => omit           	  vb	:o
omitted        	 vbn => omit           	  vb	:o
once           	  rb => once           	  rb	:o
one-dimensional	  jj => one-dimensional	  jj	:o
op             	  jj => op             	  jj	:o
opening        	  nn => opening        	  nn	:o
operand        	  nn => operand        	  nn	:o
operands       	 nns => operand        	  nn	:o
operation      	  nn => operation      	  nn	:o
operations     	 nns => operation      	  nn	:o
operator       	  nn => operator       	  nn	:o
operators      	 nns => operator       	  nn	:o
opposed        	 vbn => oppos          	  vb	:o
optimize       	  vb => optimize       	  vb	:o
optional       	  jj => optional       	  jj	:o
optionally     	  rb => optionally     	  rb	:o
order          	  nn => order          	  nn	:o
ordered        	 vbd => order          	  vb	:o
ordered        	 vbn => order          	  vb	:o
ordering       	  nn => ordering       	  nn	:o
ordinary       	  jj => ordinary       	  jj	:o
organization   	  nn => organization   	  nn	:o
original       	  jj => original       	  jj	:o
originally     	  rb => originally     	  rb	:o
other          	  jj => other          	  jj	:o
otherwise      	  rb => otherwise      	  rb	:o
overflow       	  nn => overflow       	  nn	:o
overlaps       	 vbp => overlap        	  vb	:o
overriding     	 vbg => overrid        	  vb	:o
overwrite      	  vb => overwrite      	  vb	:o
own            	  jj => own            	  jj	:o
package-level  	  nn => package-level  	  nn	:o
packages       	 nns => package        	  nn	:o
panic          	  jj => panic          	  jj	:o
panic          	  nn => panic          	  nn	:o
panicking      	  nn => panicking      	  nn	:o
panicking      	 vbg => panick         	  vb	:o
panics         	 nns => panic          	  nn	:o
parameter      	  nn => parameter      	  nn	:o
parameters     	 nns => parameter      	  nn	:o
parentheses    	 nns => parenthesis    	  nn	:o
parentheses    	 vbz => parenthes      	  vb	:o
parenthesized  	 vbn => parenthes      	  vb	:o
parse          	  vb => parse          	  vb	:o
parsed         	 vbn => pars           	  vb	:o
parsing        	  jj => parsing        	  jj	:o
part           	  nn => part           	  nn	:o
particular     	  jj => particular     	  jj	:o
parts          	 nns => part           	  nn	:o
pass           	  vb => pass           	  vb	:o
passed         	 vbd => pass           	  vb	:o
passing        	  nn => passing        	  nn	:o
path           	  nn => path           	  nn	:o
performed      	 vbn => perform        	  vb	:o
period         	  nn => period         	  nn	:o
permissible    	  jj => permissible    	  jj	:o
permit         	  vb => permit         	  vb	:o
permits        	 vbz => permit         	  vb	:o
permitted      	 vbn => permit         	  vb	:o
permitting     	 vbg => permit         	  vb	:o
phases         	 nns => phase          	  nn	:o
place          	  nn => place          	  nn	:o
placed         	 vbn => place          	  vb	:o
placeholder    	  nn => placeholder    	  nn	:o
plain          	  nn => plain          	  nn	:o
point          	  nn => point          	  nn	:o
pointed        	 vbn => point          	  vb	:o
pointer        	  nn => pointer        	  nn	:o
pointer-receiver	  jj => pointer-receiver	  jj	:o
pointers       	 nns => pointer        	  nn	:o
pointing       	 vbg => point          	  vb	:o
points         	 nns => point          	  nn	:o
portability    	  nn => portability    	  nn	:o
portable       	  jj => portable       	  jj	:o
position       	  nn => position       	  nn	:o
possible       	  jj => possible       	  jj	:o
possibly       	  rb => possibly       	  rb	:o
post           	  nn => post           	  nn	:o
power          	  nn => power          	  nn	:o
preceded       	 vbn => preced         	  vb	:o
precedence     	  nn => precedence     	  nn	:o
preceding      	 vbg => preced         	  vb	:o
precise        	  jj => precise        	  jj	:o
precisely      	  rb => precisely      	  rb	:o
precision      	  nn => precision      	  nn	:o
predeclared    	  jj => predeclared    	  jj	:o
predeclared    	 vbn => predeclar      	  vb	:o
predeclares    	 vbz => predeclar      	  vb	:o
prefix         	  nn => prefix         	  nn	:o
prefixed       	 vbn => prefix         	  vb	:o
present        	  jj => present        	  jj	:o
present        	  vb => present        	  vb	:o
presented      	 vbn => present        	  vb	:o
preventing     	 vbg => prevent        	  vb	:o
prevents       	 vbz => prevent        	  vb	:o
previous       	  jj => previous       	  jj	:o
previously     	  rb => previously     	  rb	:o
primary        	  jj => primary        	  jj	:o
prime          	  jj => prime          	  jj	:o
printing       	  nn => printing       	  nn	:o
proceed        	  vb => proceed        	  vb	:o
proceeds       	 nns => proceed        	  nn	:o
process        	  nn => process        	  nn	:o
produce        	  vb => produce        	  vb	:o
produced       	 vbn => produc         	  vb	:o
produces       	 vbz => produc         	  vb	:o
production     	  nn => production     	  nn	:o
productions    	 nns => production     	  nn	:o
program        	  nn => program        	  nn	:o
program-defined	  jj => program-defined	  jj	:o
programming    	  nn => programming    	  nn	:o
programs       	 nns => program        	  nn	:o
promoted       	 vbn => promot         	  vb	:o
properties     	 nns => property       	  nn	:o
protects       	 vbz => protect        	  vb	:o
provide        	 vbp => provid         	  vb	:o
provided       	 vbn => provid         	  vb	:o
provides       	 vbz => provid         	  vb	:o
pseudo-random  	  jj => pseudo-random  	  jj	:o
punctuation    	  nn => punctuation    	  nn	:o
purpose        	  nn => purpose        	  nn	:o
qualified      	  jj => qualified      	  jj	:o
qualified      	 vbn => qualifi        	  vb	:o
qualifier      	  nn => qualifier      	  nn	:o
queues         	 nns => queue          	  nn	:o
quote          	  nn => quote          	  nn	:o
quoted         	 vbn => quot           	  vb	:o
quotes         	 nns => quote          	  nn	:o
quotient       	  nn => quotient       	  nn	:o
radix          	  nn => radix          	  nn	:o
raised         	 vbn => rais           	  vb	:o
range          	  nn => range          	  nn	:o
ranges         	 nns => range          	  nn	:o
rare           	  jj => rare           	  jj	:o
rather         	  rb => rather         	  rb	:o
raw            	  jj => raw            	  jj	:o
re-used        	  jj => re-used        	  jj	:o
re-uses        	 vbz => re-us          	  vb	:o
reach          	  vb => reach          	  vb	:o
reachable      	  jj => reachable      	  jj	:o
reached        	 vbd => reach          	  vb	:o
reaches        	 nns => reach          	  nn	:o
read           	  vb => read           	  vb	:o
readability    	  nn => readability    	  nn	:o
ready          	  jj => ready          	  jj	:o
ready          	 vbp => readi          	  vb	:o
real           	  jj => real           	  jj	:o
receive        	  nn => receive        	  nn	:o
receive        	 vbp => receiv         	  vb	:o
receive-only   	  jj => receive-only   	  jj	:o
received       	  jj => received       	  jj	:o
received       	 vbn => receiv         	  vb	:o
receiver       	  nn => receiver       	  nn	:o
receives       	 nns => receife        	  nn	:o
receiving      	 vbg => receiv         	  vb	:o
recent         	  jj => recent         	  jj	:o
records        	 nns => record         	  nn	:o
recursively    	  rb => recursively    	  rb	:o
redeclaration  	  nn => redeclaration  	  nn	:o
redeclare      	  vb => redeclare      	  vb	:o
redeclared     	 vbn => redeclar       	  vb	:o
refer          	  vb => refer          	  vb	:o
reference      	  nn => reference      	  nn	:o
referenced     	 vbn => referenc       	  vb	:o
references     	 vbz => refer          	  vb	:o
referred       	 vbn => refer          	  vb	:o
referring      	 vbg => refer          	  vb	:o
refers         	 nns => refer          	  nn	:o
reflect        	  vb => reflect        	  vb	:o
reflection     	  nn => reflection     	  nn	:o
regardless     	  rb => regardless     	  rb	:o
regular        	  jj => regular        	  jj	:o
related        	  jj => related        	  jj	:o
relation       	  nn => relation       	  nn	:o
relationship   	  nn => relationship   	  nn	:o
relationships  	 nns => relationship   	  nn	:o
relative       	 vbp => relat          	  vb	:o
rely           	  vb => rely           	  vb	:o
remain         	 vbp => remain         	  vb	:o
remainder      	  nn => remainder      	  nn	:o
remains        	 vbz => remain         	  vb	:o
removed        	 vbn => remov          	  vb	:o
removes        	 vbz => remov          	  vb	:o
repeated       	  jj => repeated       	  jj	:o
repeatedly     	  rb => repeatedly     	  rb	:o
repeating      	 vbg => repeat         	  vb	:o
repetition     	  nn => repetition     	  nn	:o
replaced       	 vbn => replac         	  vb	:o
replacement    	  nn => replacement    	  nn	:o
reported       	 vbn => report         	  vb	:o
reporting      	  nn => reporting      	  nn	:o
reports        	 vbz => report         	  vb	:o
repository     	  nn => repository     	  nn	:o
represent      	 vbp => repres         	  vb	:o
representable  	  jj => representable  	  jj	:o
representation 	  nn => representation 	  nn	:o
representations	 nns => representation 	  nn	:o
represented    	 vbn => repres         	  vb	:o
representing   	 vbg => repres         	  vb	:o
represents     	 vbz => repres         	  vb	:o
reproducible   	  jj => reproducible   	  jj	:o
require        	  vb => require        	  vb	:o
required       	 vbn => requir         	  vb	:o
requirement    	  nn => requirement    	  nn	:o
requirements   	 nns => requirement    	  nn	:o
reserved       	 vbn => reserv         	  vb	:o
reserves       	 nns => reserf         	  nn	:o
resolve        	  vb => resolve        	  vb	:o
respective     	  jj => respective     	  jj	:o
respectively   	  rb => respectively   	  rb	:o
restrict       	  vb => restrict       	  vb	:o
restricted     	 vbn => restrict       	  vb	:o
restriction    	  nn => restriction    	  nn	:o
restrictions   	 nns => restriction    	  nn	:o
result         	  nn => result         	  nn	:o
resulting      	 vbg => result         	  vb	:o
results        	 nns => result         	  nn	:o
resumes        	 nns => resume         	  nn	:o
retrieved      	 vbn => retriev        	  vb	:o
return         	  nn => return         	  nn	:o
return         	  vb => return         	  vb	:o
returned       	 vbn => return         	  vb	:o
returning      	 vbg => return         	  vb	:o
returns        	 nns => return         	  nn	:o
returns        	 vbz => return         	  vb	:o
reverse        	  nn => reverse        	  nn	:o
rewritten      	 vbn => rewritten      	  vb	:o
right          	  nn => right          	  nn	:o
right          	  vb => right          	  vb	:o
right-hand     	  jj => right-hand     	  jj	:o
right-hand-side	  jj => right-hand-side	  jj	:o
room           	  nn => room           	  nn	:o
round-to-even  	  jj => round-to-even  	  jj	:o
rounded        	 vbn => round          	  vb	:o
rounding       	  nn => rounding       	  nn	:o
rounding       	 vbg => round          	  vb	:o
rounds         	 vbz => round          	  vb	:o
routine        	  nn => routine        	  nn	:o
rule           	  nn => rule           	  nn	:o
rules          	 nns => rule           	  nn	:o
run            	  vb => run            	  vb	:o
run            	 vbn => run            	  vb	:o
run-time       	  jj => run-time       	  jj	:o
rune           	  nn => rune           	  nn	:o
runes          	 nns => rune           	  nn	:o
running        	  nn => running        	  nn	:o
safety         	  nn => safety         	  nn	:o
said           	 vbd => said           	  vb	:o
satisfies      	 vbz => satisfi        	  vb	:o
satisfy        	 vbp => satisfi        	  vb	:o
saved          	 vbd => save           	  vb	:o
scales         	 vbz => scale          	  vb	:o
scope          	  nn => scope          	  nn	:o
scoped         	 nns => scoped         	 nns	:o
scopes         	 vbz => scope          	  vb	:o
scoping        	  nn => scoping        	  nn	:o
second         	  jj => second         	  jj	:o
section        	  nn => section        	  nn	:o
see            	  vb => see            	  vb	:o
segment        	  nn => segment        	  nn	:o
select         	  jj => select         	  jj	:o
select         	  nn => select         	  nn	:o
selected       	 vbn => select         	  vb	:o
selecting      	 vbg => select         	  vb	:o
selection      	  nn => selection      	  nn	:o
selector       	  nn => selector       	  nn	:o
selectors      	 nns => selector       	  nn	:o
semantically   	  rb => semantically   	  rb	:o
semicolon      	  nn => semicolon      	  nn	:o
semicolons     	 nns => semicolon      	  nn	:o
send           	  vb => send           	  vb	:o
sender         	  nn => sender         	  nn	:o
sending        	 vbg => send           	  vb	:o
sends          	 nns => send           	  nn	:o
sends          	 vbz => send           	  vb	:o
sent           	  nn => sent           	  nn	:o
sent           	 vbn => sent           	  vb	:o
separates      	 vbz => separ          	  vb	:o
sequence       	  nn => sequence       	  nn	:o
sequences      	 vbz => sequenc        	  vb	:o
sequential     	  jj => sequential     	  jj	:o
sequentially   	  rb => sequentially   	  rb	:o
serve          	 vbp => serv           	  vb	:o
serves         	 vbz => serv           	  vb	:o
set            	  nn => set            	  nn	:o
set            	 vbn => set            	  vb	:o
sets           	 vbz => set            	  vb	:o
setting        	 vbg => set            	  vb	:o
several        	  jj => several        	  jj	:o
shallowest     	  nn => shallowest     	  nn	:o
share          	  nn => share          	  nn	:o
shared         	 vbn => share          	  vb	:o
shares         	 nns => share          	  nn	:o
sharing        	 vbg => share          	  vb	:o
shift          	  nn => shift          	  nn	:o
shifted        	 vbn => shift          	  vb	:o
shifts         	 nns => shift          	  nn	:o
short          	  jj => short          	  jj	:o
shorthand      	  nn => shorthand      	  nn	:o
show           	 vbp => show           	  vb	:o
side           	  nn => side           	  nn	:o
side-effects   	 nns => side-effect    	  nn	:o
sieve          	  nn => sieve          	  nn	:o
sign           	  jj => sign           	  jj	:o
signature      	  nn => signature      	  nn	:o
signatures     	 nns => signature      	  nn	:o
signed         	 vbn => sign           	  vb	:o
significantly  	  rb => significantly  	  rb	:o
similar        	  jj => similar        	  jj	:o
simple         	  nn => simple         	  nn	:o
simplest       	 jjs => simpl          	  jj	:o
simplicity     	  nn => simplicity     	  nn	:o
simplified     	 vbd => simplifi       	  vb	:o
single         	  jj => single         	  jj	:o
single-character	  jj => single-character	  jj	:o
single-valued  	  jj => single-valued  	  jj	:o
site           	  nn => site           	  nn	:o
size           	  nn => size           	  nn	:o
sizes          	 nns => size           	  nn	:o
skipped        	 vbn => skip           	  vb	:o
skips          	 pdt => skips          	 pdt	:o
sliced         	  jj => sliced         	  jj	:o
slices         	 nns => slice          	  nn	:o
slicing        	 vbg => slice          	  vb	:o
snippets       	 nns => snippet        	  nn	:o
so             	  rb => so             	  rb	:o
solely         	  rb => solely         	  rb	:o
sometimes      	  rb => sometimes      	  rb	:o
source         	  nn => source         	  nn	:o
space          	  nn => space          	  nn	:o
spaces         	 nns => space          	  nn	:o
speaking       	 vbg => speak          	  vb	:o
spec           	  nn => spec           	  nn	:o
special        	  jj => special        	  jj	:o
specially      	  rb => specially      	  rb	:o
specific       	  jj => specific       	  jj	:o
specification  	  nn => specification  	  nn	:o
specifications 	 nns => specification  	  nn	:o
specified      	 vbn => specifi        	  vb	:o
specifier      	  nn => specifier      	  nn	:o
specifies      	 vbz => specifi        	  vb	:o
specify        	  vb => specify        	  vb	:o
specifying     	 vbg => specifi        	  vb	:o
spelled        	 vbn => spell          	  vb	:o
square         	  jj => square         	  jj	:o
standard       	  nn => standard       	  nn	:o
standard       	 vbn => standard       	  vb	:o
stands         	 vbz => stand          	  vb	:o
start          	  vb => start          	  vb	:o
starting       	 vbg => start          	  vb	:o
starts         	 vbz => start          	  vb	:o
state          	  nn => state          	  nn	:o
statement      	  nn => statement      	  nn	:o
statements     	 nns => statement      	  nn	:o
states         	 vbz => state          	  vb	:o
static         	  jj => static         	  jj	:o
stay           	  vb => stay           	  vb	:o
step           	  nn => step           	  nn	:o
steps          	 nns => step           	  nn	:o
stepwise       	  nn => stepwise       	  nn	:o
still          	  rb => still          	  rb	:o
stop           	  vb => stop           	  vb	:o
stops          	 nns => stop           	  nn	:o
storage        	  nn => storage        	  nn	:o
store          	  vb => store          	  vb	:o
stored         	 vbn => store          	  vb	:o
stream         	  nn => stream         	  nn	:o
string         	  nn => string         	  nn	:o
string         	 vbg => string         	  vb	:o
strings        	 nns => string         	  nn	:o
strongest      	 jjs => strong         	  jj	:o
strongly       	  rb => strongly       	  rb	:o
struct         	  nn => struct         	  nn	:o
structs        	 nns => struct         	  nn	:o
structurally   	  rb => structurally   	  rb	:o
structure      	  nn => structure      	  nn	:o
structured     	  jj => structured     	  jj	:o
subexpressions 	 nns => subexpression  	  nn	:o
subsequent     	  jj => subsequent     	  jj	:o
subset         	  nn => subset         	  nn	:o
substitution   	  nn => substitution   	  nn	:o
substring      	  nn => substring      	  nn	:o
succeeded      	 vbd => succeed        	  vb	:o
succeeds       	 vbz => succeed        	  vb	:o
successful     	  jj => successful     	  jj	:o
successive     	  jj => successive     	  jj	:o
such           	  jj => such           	  jj	:o
sufficiently   	  rb => sufficiently   	  rb	:o
sum            	  nn => sum            	  nn	:o
superset       	  nn => superset       	  nn	:o
support        	  nn => support        	  nn	:o
supported      	 vbn => support        	  vb	:o
surrogate      	  jj => surrogate      	  jj	:o
surrounding    	 vbg => surround       	  vb	:o
survive        	 vbp => surviv         	  vb	:o
switch         	  nn => switch         	  nn	:o
switch         	  vb => switch         	  vb	:o
switches       	 nns => switch         	  nn	:o
switches       	 vbz => switch         	  vb	:o
synchronization	  nn => synchronization	  nn	:o
syntax         	  nn => syntax         	  nn	:o
system         	  nn => system         	  nn	:o
systems        	 nns => system         	  nn	:o
table          	  nn => table          	  nn	:o
tabs           	  nn => tabs           	  nn	:o
tag            	  nn => tag            	  nn	:o
tags           	 nns => tag            	  nn	:o
take           	  vb => take           	  vb	:o
takes          	 vbz => take           	  vb	:o
taking         	 vbg => take           	  vb	:o
target         	  nn => target         	  nn	:o
temporary      	  jj => temporary      	  jj	:o
term           	  nn => term           	  nn	:o
terminated     	 vbn => termin         	  vb	:o
terminates     	 nns => terminate      	  nn	:o
terminates     	 vbz => termin         	  vb	:o
terminating    	  nn => terminating    	  nn	:o
terminating    	 vbg => termin         	  vb	:o
termination    	  nn => termination    	  nn	:o
terminators    	 nns => terminator     	  nn	:o
terms          	 nns => term           	  nn	:o
tested         	 vbn => test           	  vb	:o
text           	  nn => text           	  nn	:o
textual        	  jj => textual        	  jj	:o
then           	  rb => then           	  rb	:o
there          	  ex => there          	  ex	:o
therefore      	  rb => therefore      	  rb	:o
thread         	  nn => thread         	  nn	:o
three-digit    	  jj => three-digit    	  jj	:o
thus           	  rb => thus           	  rb	:o
time           	  nn => time           	  nn	:o
times          	 nns => time           	  nn	:o
together       	  rb => together       	  rb	:o
token          	  nn => token          	  nn	:o
tokens         	 nns => token          	  nn	:o
too            	  rb => too            	  rb	:o
tools          	 nns => tool           	  nn	:o
top            	  jj => top            	  jj	:o
top-level      	  jj => top-level      	  jj	:o
top-to-bottom  	  jj => top-to-bottom  	  jj	:o
transfers      	 nns => transfer       	  nn	:o
transitively   	  rb => transitively   	  rb	:o
traversed      	 vbd => travers        	  vb	:o
treated        	 vbn => treat          	  vb	:o
trigger        	 vbp => trigger        	  vb	:o
triggers       	 nns => trigger        	  nn	:o
true           	  jj => true           	  jj	:o
truncated      	 vbn => truncat        	  vb	:o
truncation     	  nn => truncation     	  nn	:o
truth          	  nn => truth          	  nn	:o
tuple          	  jj => tuple          	  jj	:o
turn           	  nn => turn           	  nn	:o
twice          	  rb => twice          	  rb	:o
two-digit      	  jj => two-digit      	  jj	:o
type           	  nn => type           	  nn	:o
type-specific  	  jj => type-specific  	  jj	:o
typed          	  jj => typed          	  jj	:o
types          	 nns => type           	  nn	:o
types—array    	  nn => types—array    	  nn	:o
types—may      	  rb => types—may      	  rb	:o
typically      	  rb => typically      	  rb	:o
unable         	  jj => unable         	  jj	:o
unary          	  jj => unary          	  jj	:o
unbuffered     	  jj => unbuffered     	  jj	:o
unchanged      	  jj => unchanged      	  jj	:o
underlying     	 vbg => under          	  vb	:o
underscore     	  jj => underscore     	  jj	:o
underscores    	 nns => underscore     	  nn	:o
unescaped      	  jj => unescaped      	  jj	:o
uniform        	  jj => uniform        	  jj	:o
unimported     	  jj => unimported     	  jj	:o
uninitialized  	  jj => uninitialized  	  jj	:o
uninterpreted  	  jj => uninterpreted  	  jj	:o
union          	  nn => union          	  nn	:o
unique         	  jj => unique         	  jj	:o
unit           	  nn => unit           	  nn	:o
universe       	  jj => universe       	  jj	:o
unnamed        	  jj => unnamed        	  jj	:o
unordered      	  jj => unordered      	  jj	:o
unparenthesized	  jj => unparenthesized	  jj	:o
unqualified    	  jj => unqualified    	  jj	:o
unsigned       	  jj => unsigned       	  jj	:o
unspecified    	  jj => unspecified    	  jj	:o
untyped        	  jj => untyped        	  jj	:o
upper          	  jj => upper          	  jj	:o
used           	 vbn => use            	  vb	:o
useful         	  jj => useful         	  jj	:o
uses           	 vbz => use            	  vb	:o
using          	 vbg => use            	  vb	:o
usual          	  jj => usual          	  jj	:o
valid          	  jj => valid          	  jj	:o
value          	  nn => value          	  nn	:o
value-receiver 	  jj => value-receiver 	  jj	:o
values         	 nns => value          	  nn	:o
variable       	  jj => variable       	  jj	:o
variable       	  nn => variable       	  nn	:o
variables      	 nns => variable       	  nn	:o
variadic       	  jj => variadic       	  jj	:o
variants       	 nns => variant        	  nn	:o
various        	  jj => various        	  jj	:o
vary           	  vb => vary           	  vb	:o
versa          	  nn => versa          	  nn	:o
vetted         	 vbn => vet            	  vb	:o
vice           	  nn => vice           	  nn	:o
violate        	 vbp => violat         	  vb	:o
visible        	  jj => visible        	  jj	:o
vocabulary     	  nn => vocabulary     	  nn	:o
wait           	  vb => wait           	  vb	:o
was            	 vbd => was            	  vb	:o
way            	  nn => way            	  nn	:o
ways           	 nns => way            	  nn	:o
well           	  rb => well           	  rb	:o
were           	 vbd => were           	  vb	:o
wide           	  jj => wide           	  jj	:o
width          	  nn => width          	  nn	:o
wishes         	 vbz => wish           	  vb	:o
word           	  nn => word           	  nn	:o
words          	 nns => word           	  nn	:o
wrap           	  nn => wrap           	  nn	:o
write          	  vb => write          	  vb	:o
written        	 vbn => written        	  vb	:o
yet            	  rb => yet            	  rb	:o
yield          	  vb => yield          	  vb	:o
yielding       	 vbg => yield          	  vb	:o
yields         	 nns => yield          	  nn	:o
zero-size      	  jj => zero-size      	  jj	:o