Words frequency in Go's spec

words_frequency.txt

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

See my new project https://github.com/DQNEO/gospec-analyzer