code stringlengths 114 1.05M | path stringlengths 3 312 | quality_prob float64 0.5 0.99 | learning_prob float64 0.2 1 | filename stringlengths 3 168 | kind stringclasses 1 value |
|---|---|---|---|---|---|
package goja
import (
"math"
)
//Math.abs(x)
//返回一个数的绝对值。
func (r *Runtime) math_abs(call FunctionCall) Value {
return floatToValue(math.Abs(call.Argument(0).ToFloat()))
}
//Math.acos(x)
//返回一个数的反余弦值。
func (r *Runtime) math_acos(call FunctionCall) Value {
return floatToValue(math.Acos(call.Argument(0).ToFloat()))
}
//Math.asin(x)
//返回一个数的反正弦值。
func (r *Runtime) math_asin(call FunctionCall) Value {
return floatToValue(math.Asin(call.Argument(0).ToFloat()))
}
//Math.atan(x)
//返回一个数的反正切值。
func (r *Runtime) math_atan(call FunctionCall) Value {
return floatToValue(math.Atan(call.Argument(0).ToFloat()))
}
//Math.atan2(y, x)
//返回 y/x 的反正切值。
func (r *Runtime) math_atan2(call FunctionCall) Value {
y := call.Argument(0).ToFloat()
x := call.Argument(1).ToFloat()
return floatToValue(math.Atan2(y, x))
}
//Math.ceil(x)
//返回大于一个数的最小整数，即一个数向上取整后的值。
func (r *Runtime) math_ceil(call FunctionCall) Value {
return floatToValue(math.Ceil(call.Argument(0).ToFloat()))
}
//Math.cos(x)
//返回一个数的余弦值。
func (r *Runtime) math_cos(call FunctionCall) Value {
return floatToValue(math.Cos(call.Argument(0).ToFloat()))
}
//Math.exp(x)
//返回欧拉常数的参数次方，Ex，其中 x 为参数，E 是欧拉常数（2.718...，自然对数的底数）。
func (r *Runtime) math_exp(call FunctionCall) Value {
return floatToValue(math.Exp(call.Argument(0).ToFloat()))
}
//Math.floor(x)
//返回小于一个数的最大整数，即一个数向下取整后的值。
func (r *Runtime) math_floor(call FunctionCall) Value {
return floatToValue(math.Floor(call.Argument(0).ToFloat()))
}
//Math.log(x)
//返回一个数的自然对数（㏒e，即 ㏑）。
func (r *Runtime) math_log(call FunctionCall) Value {
return floatToValue(math.Log(call.Argument(0).ToFloat()))
}
//Math.max([x[, y[, …]]])
//返回零到多个数值中最大值。
func (r *Runtime) math_max(call FunctionCall) Value {
if len(call.Arguments) == 0 {
return _negativeInf
}
result := call.Arguments[0].ToFloat()
if math.IsNaN(result) {
return _NaN
}
for _, arg := range call.Arguments[1:] {
f := arg.ToFloat()
if math.IsNaN(f) {
return _NaN
}
result = math.Max(result, f)
}
return floatToValue(result)
}
//Math.min([x[, y[, …]]])
//返回零到多个数值中最小值。
func (r *Runtime) math_min(call FunctionCall) Value {
if len(call.Arguments) == 0 {
return _positiveInf
}
result := call.Arguments[0].ToFloat()
if math.IsNaN(result) {
return _NaN
}
for _, arg := range call.Arguments[1:] {
f := arg.ToFloat()
if math.IsNaN(f) {
return _NaN
}
result = math.Min(result, f)
}
return floatToValue(result)
}
//Math.pow(x, y)
//返回一个数的 y 次幂。
func (r *Runtime) math_pow(call FunctionCall) Value {
x := call.Argument(0)
y := call.Argument(1)
if x, ok := x.assertInt(); ok {
if y, ok := y.assertInt(); ok && y >= 0 && y < 64 {
if y == 0 {
return intToValue(1)
}
if x == 0 {
return intToValue(0)
}
ip := ipow(x, y)
if ip != 0 {
return intToValue(ip)
}
}
}
return floatToValue(math.Pow(x.ToFloat(), y.ToFloat()))
}
//Math.random()
//返回一个 0 到 1 之间的伪随机数。
func (r *Runtime) math_random(call FunctionCall) Value {
return floatToValue(r.rand())
}
//Math.round(x)
//返回四舍五入后的整数。
func (r *Runtime) math_round(call FunctionCall) Value {
f := call.Argument(0).ToFloat()
if math.IsNaN(f) {
return _NaN
}
if f == 0 && math.Signbit(f) {
return _negativeZero
}
t := math.Trunc(f)
if f >= 0 {
if f-t >= 0.5 {
return floatToValue(t + 1)
}
} else {
if t-f > 0.5 {
return floatToValue(t - 1)
}
}
return floatToValue(t)
}
//Math.sin(x)
//返回一个数的正弦值。
func (r *Runtime) math_sin(call FunctionCall) Value {
return floatToValue(math.Sin(call.Argument(0).ToFloat()))
}
//Math.sqrt(x)
//返回一个数的平方根。
func (r *Runtime) math_sqrt(call FunctionCall) Value {
return floatToValue(math.Sqrt(call.Argument(0).ToFloat()))
}
//Math.tan(x)
//返回一个数的正切值。
func (r *Runtime) math_tan(call FunctionCall) Value {
return floatToValue(math.Tan(call.Argument(0).ToFloat()))
}
// Math库函数注入
func (r *Runtime) createMath(val *Object) objectImpl {
m := &baseObject{
class: "Math",
val: val,
extensible: true,
prototype: r.global.ObjectPrototype,
}
m.init()
//欧拉常数，也是自然对数的底数，约等于 2.718。
m._putProp("E", valueFloat(math.E), false, false, false)
//10 的自然对数，约等于 2.303。
m._putProp("LN10", valueFloat(math.Ln10), false, false, false)
//2 的自然对数，约等于 0.693。
m._putProp("LN2", valueFloat(math.Ln2), false, false, false)
//以 2 为底的 E 的对数，约等于 1.443。
m._putProp("LOG2E", valueFloat(math.Log2E), false, false, false)
//以 10 为底的 E 的对数，约等于 0.434。
m._putProp("LOG10E", valueFloat(math.Log10E), false, false, false)
//圆周率，一个圆的周长和直径之比，约等于 3.14159。
m._putProp("PI", valueFloat(math.Pi), false, false, false)
//二分之一 ½ 的平方根，同时也是 2 的平方根的倒数 ，约等于 0.707。
m._putProp("SQRT1_2", valueFloat(sqrt1_2), false, false, false)
//2 的平方根，约等于 1.414。
m._putProp("SQRT2", valueFloat(math.Sqrt2), false, false, false)
m._putProp("abs", r.newNativeFunc(r.math_abs, nil, "abs", nil, 1), true, false, true)
m._putProp("acos", r.newNativeFunc(r.math_acos, nil, "acos", nil, 1), true, false, true)
m._putProp("asin", r.newNativeFunc(r.math_asin, nil, "asin", nil, 1), true, false, true)
m._putProp("atan", r.newNativeFunc(r.math_atan, nil, "atan", nil, 1), true, false, true)
m._putProp("atan2", r.newNativeFunc(r.math_atan2, nil, "atan2", nil, 2), true, false, true)
m._putProp("ceil", r.newNativeFunc(r.math_ceil, nil, "ceil", nil, 1), true, false, true)
m._putProp("cos", r.newNativeFunc(r.math_cos, nil, "cos", nil, 1), true, false, true)
m._putProp("exp", r.newNativeFunc(r.math_exp, nil, "exp", nil, 1), true, false, true)
m._putProp("floor", r.newNativeFunc(r.math_floor, nil, "floor", nil, 1), true, false, true)
m._putProp("log", r.newNativeFunc(r.math_log, nil, "log", nil, 1), true, false, true)
m._putProp("max", r.newNativeFunc(r.math_max, nil, "max", nil, 2), true, false, true)
m._putProp("min", r.newNativeFunc(r.math_min, nil, "min", nil, 2), true, false, true)
m._putProp("pow", r.newNativeFunc(r.math_pow, nil, "pow", nil, 2), true, false, true)
m._putProp("random", r.newNativeFunc(r.math_random, nil, "random", nil, 0), true, false, true)
m._putProp("round", r.newNativeFunc(r.math_round, nil, "round", nil, 1), true, false, true)
m._putProp("sin", r.newNativeFunc(r.math_sin, nil, "sin", nil, 1), true, false, true)
m._putProp("sqrt", r.newNativeFunc(r.math_sqrt, nil, "sqrt", nil, 1), true, false, true)
m._putProp("tan", r.newNativeFunc(r.math_tan, nil, "tan", nil, 1), true, false, true)
return m
}
// Math库的注入
func (r *Runtime) initMath() {
r.addToGlobal("Math", r.newLazyObject(r.createMath))
} | builtin_math.go | 0.547948 | 0.583678 | builtin_math.go | starcoder |
package wotoCrypto
import (
"crypto/aes"
"strings"
)
// GenerateFutureKey is supposed to generate a new future key by using
// the specified paskey's algorithm.
func GenerateFutureKey(pastKey WotoKey) WotoKey {
return &futureKey{
algorithm: pastKey.GetAlgorithm(),
}
}
func GeneratePresentKey(algo WotoAlgorithm) WotoKey {
return &presentKey{
algorithm: algo,
}
}
func EncryptData(key, data []byte) []byte {
keyBlocks := toBlockCollection(key)
dataBlocks := toBlockCollection(data)
return encryptByBlocks(keyBlocks, dataBlocks, nil)
}
func DecryptData(key, data []byte) []byte {
keyBlocks := toBlockCollection(key)
dataBlocks := toBlockCollection(data)
return decryptByBlocks(keyBlocks, dataBlocks, nil)
}
// encryptByBlocksNoAlgorithm encrypts the data with the specified key to the destinated
// block collection without using any algorithm.
func encryptByBlocksNoAlgorithm(dest, key, data blockCollection) []byte {
for index, current := range data.GetBlocks() {
dest.AppendBlock(current.Sum(key.GetBlockByIndex(index)))
}
buff, _ := dest.ToBytes()
return buff
}
// decryptByBlocksNoAlgorithm decrypts the data with the specified key to the destinated
// block collection without using any algorithm.
func decryptByBlocksNoAlgorithm(dest, key, data blockCollection) []byte {
for index, current := range data.GetBlocks() {
dest.AppendBlock(current.Min(key.GetBlockByIndex(index)))
}
buff, _ := dest.ToBytes()
return buff
}
func encryptByBlocks(key, data blockCollection, algorithm blockAlgorithm) []byte {
finalCollection := getEmptyCollection()
if algorithm == nil {
return encryptByBlocksNoAlgorithm(finalCollection, key, data)
}
var action blockAction
var actionFactor bool
for index, current := range data.GetBlocks() {
action = algorithm.GetEncryptBlockAction(index)
if action == nil {
continue
}
if !actionFactor {
actionFactor = true
}
finalCollection.AppendBlock(action(current, key.GetBlockByIndex(index)))
}
if !actionFactor {
return encryptByBlocksNoAlgorithm(finalCollection, key, data)
}
buff, _ := finalCollection.ToBytes()
return buff
}
func decryptByBlocks(key, data blockCollection, algorithm blockAlgorithm) []byte {
finalCollection := getEmptyCollection()
if algorithm == nil {
return decryptByBlocksNoAlgorithm(finalCollection, key, data)
}
var action blockAction
var actionFactor bool
for index, current := range data.GetBlocks() {
action = algorithm.GetDecryptBlockAction(index)
if action == nil {
continue
}
finalCollection.AppendBlock(action(current, key.GetBlockByIndex(index)))
}
if !actionFactor {
return decryptByBlocksNoAlgorithm(finalCollection, key, data)
}
buff, _ := finalCollection.ToBytes()
return buff
}
func EncryptAES(key, data []byte) []byte {
if len(data) < aes.BlockSize {
l := len(data)
for i := 0; i < aes.BlockSize-l; i++ {
data = append(data, 0x20)
}
}
b, err := aes.NewCipher(key)
if err != nil {
return data
}
dest := make([]byte, len(data))
b.Encrypt(dest, data)
return dest
}
func BlockAlgorithmExists(algorithmId uint8) bool {
return _blockActionsMap[blockAlgorithmId(algorithmId)] != nil
}
func DecryptAES(key, data []byte) []byte {
b, err := aes.NewCipher(key)
if err != nil {
return data
}
dest := make([]byte, len(data))
b.Decrypt(dest, data)
return []byte(strings.TrimSpace(string(dest)))
}
func toBlockCollection(data []byte) blockCollection {
return &privateCollection{
blocks: toSingleBlocks(data),
}
}
func toSingleBlocks(data []byte) []privateBlock {
var finalValue []privateBlock
for _, current := range string(data) {
finalValue = append(finalValue, privateBlock(current))
}
return finalValue
}
func getEmptyCollection() blockCollection {
return &privateCollection{}
}
func blockActionSum(first, second singleBlock) singleBlock {
return first.Sum(second)
}
func blockActionMin(first, second singleBlock) singleBlock {
return first.Min(second)
}
func blockActionMul(first, second singleBlock) singleBlock {
return first.Mul(second)
}
func blockActionDiv(first, second singleBlock) singleBlock {
return first.Div(second)
} | wotoCrypto/helpers.go | 0.745213 | 0.402686 | helpers.go | starcoder |
package semantic
import (
"fmt"
"github.com/influxdata/flux/ast"
)
// ToAST will construct an AST from the semantic graph.
// The AST will not be preserved when going from
// AST -> semantic -> AST, but going from
// semantic -> AST -> semantic should result in the same graph.
func ToAST(n Node) ast.Node {
switch n := n.(type) {
case *Package:
p := &ast.Package{
Package: n.Package,
Files: make([]*ast.File, len(n.Files)),
}
for i, f := range n.Files {
p.Files[i] = ToAST(f).(*ast.File)
}
return p
case *File:
f := &ast.File{
Package: ToAST(n.Package).(*ast.PackageClause),
Body: make([]ast.Statement, len(n.Body)),
}
if n.Imports != nil {
f.Imports = make([]*ast.ImportDeclaration, len(n.Imports))
for i, imp := range n.Imports {
f.Imports[i] = ToAST(imp).(*ast.ImportDeclaration)
}
}
for i, stmt := range n.Body {
f.Body[i] = ToAST(stmt).(ast.Statement)
}
return f
case *Block:
b := &ast.Block{
Body: make([]ast.Statement, len(n.Body)),
}
for i, stmt := range n.Body {
b.Body[i] = ToAST(stmt).(ast.Statement)
}
return b
case *PackageClause:
return &ast.PackageClause{
Name: &ast.Identifier{Name: n.Name.Name},
}
case *ImportDeclaration:
decl := &ast.ImportDeclaration{
Path: &ast.StringLiteral{Value: n.Path.Value},
}
if n.As != nil {
decl.As = &ast.Identifier{Name: n.As.Name}
}
return decl
case *OptionStatement:
assign := ToAST(n.Assignment).(ast.Assignment)
if m, ok := assign.(*ast.MemberAssignment); ok {
// Option statements must use identifiers for the property.
// This only occurs when using a member assignment which
// defaults to using a string literal.
if v, ok := m.Member.Property.(*ast.StringLiteral); ok {
m.Member.Property = &ast.Identifier{Name: v.Value}
}
}
return &ast.OptionStatement{
Assignment: assign,
}
case *BuiltinStatement:
return &ast.BuiltinStatement{
ID: &ast.Identifier{Name: n.ID.Name},
}
case *TestStatement:
return &ast.TestStatement{
Assignment: ToAST(n.Assignment).(*ast.VariableAssignment),
}
case *ExpressionStatement:
return &ast.ExpressionStatement{
Expression: ToAST(n.Expression).(ast.Expression),
}
case *ReturnStatement:
return &ast.ReturnStatement{
Argument: ToAST(n.Argument).(ast.Expression),
}
case *MemberAssignment:
return &ast.MemberAssignment{
Init: ToAST(n.Init).(ast.Expression),
Member: &ast.MemberExpression{
Object: ToAST(n.Member.Object).(ast.Expression),
Property: &ast.StringLiteral{Value: n.Member.Property},
},
}
case *NativeVariableAssignment:
return &ast.VariableAssignment{
ID: &ast.Identifier{Name: n.Identifier.Name},
Init: ToAST(n.Init).(ast.Expression),
}
case *StringExpression:
se := &ast.StringExpression{
Parts: make([]ast.StringExpressionPart, len(n.Parts)),
}
for i, p := range n.Parts {
se.Parts[i] = ToAST(p).(ast.StringExpressionPart)
}
return se
case *ArrayExpression:
arr := &ast.ArrayExpression{
Elements: make([]ast.Expression, len(n.Elements)),
}
for i, e := range n.Elements {
arr.Elements[i] = ToAST(e).(ast.Expression)
}
return arr
case *FunctionExpression:
fn := &ast.FunctionExpression{
Body: ToAST(n.Block),
}
if n.Parameters != nil {
fn.Params = make([]*ast.Property, len(n.Parameters.List))
for i, p := range n.Parameters.List {
fn.Params[i] = &ast.Property{
Key: &ast.Identifier{Name: p.Key.Name},
}
if n.Defaults != nil {
for _, pn := range n.Defaults.Properties {
if pn.Key.Key() == p.Key.Name {
fn.Params[i].Value = ToAST(pn.Value).(ast.Expression)
break
}
}
}
}
}
return fn
case *BinaryExpression:
return &ast.BinaryExpression{
Operator: n.Operator,
Left: ToAST(n.Left).(ast.Expression),
Right: ToAST(n.Right).(ast.Expression),
}
case *CallExpression:
call := &ast.CallExpression{
Callee: ToAST(n.Callee).(ast.Expression),
}
if n.Arguments != nil {
call.Arguments = []ast.Expression{
ToAST(n.Arguments).(ast.Expression),
}
}
return call
case *ConditionalExpression:
return &ast.ConditionalExpression{
Test: ToAST(n.Test).(ast.Expression),
Consequent: ToAST(n.Consequent).(ast.Expression),
Alternate: ToAST(n.Alternate).(ast.Expression),
}
case *IdentifierExpression:
return &ast.Identifier{Name: n.Name}
case *LogicalExpression:
return &ast.LogicalExpression{
Operator: n.Operator,
Left: ToAST(n.Left).(ast.Expression),
Right: ToAST(n.Right).(ast.Expression),
}
case *MemberExpression:
return &ast.MemberExpression{
Object: ToAST(n.Object).(ast.Expression),
Property: &ast.StringLiteral{Value: n.Property},
}
case *IndexExpression:
return &ast.IndexExpression{
Array: ToAST(n.Array).(ast.Expression),
Index: ToAST(n.Index).(ast.Expression),
}
case *ObjectExpression:
obj := &ast.ObjectExpression{}
if n.With != nil {
obj.With = &ast.Identifier{Name: n.With.Name}
}
if len(n.Properties) > 0 {
obj.Properties = make([]*ast.Property, len(n.Properties))
for i, on := range n.Properties {
obj.Properties[i] = ToAST(on).(*ast.Property)
}
}
return obj
case *UnaryExpression:
return &ast.UnaryExpression{
Operator: n.Operator,
Argument: ToAST(n.Argument).(ast.Expression),
}
case *Identifier:
return &ast.Identifier{Name: n.Name}
case *Property:
p := &ast.Property{}
switch key := n.Key.(type) {
case *Identifier:
p.Key = &ast.Identifier{Name: key.Name}
default:
p.Key = &ast.StringLiteral{Value: key.Key()}
}
if n.Value != nil {
p.Value = ToAST(n.Value).(ast.Expression)
}
return p
case *TextPart:
return &ast.TextPart{
Value: n.Value,
}
case *InterpolatedPart:
return &ast.InterpolatedPart{
Expression: ToAST(n.Expression).(ast.Expression),
}
case *BooleanLiteral:
return &ast.BooleanLiteral{Value: n.Value}
case *DateTimeLiteral:
return &ast.DateTimeLiteral{Value: n.Value}
case *DurationLiteral:
return &ast.DurationLiteral{Values: n.Values}
case *FloatLiteral:
return &ast.FloatLiteral{Value: n.Value}
case *IntegerLiteral:
return &ast.IntegerLiteral{Value: n.Value}
case *StringLiteral:
return &ast.StringLiteral{Value: n.Value}
case *RegexpLiteral:
return &ast.RegexpLiteral{Value: n.Value}
case *UnsignedIntegerLiteral:
return &ast.UnsignedIntegerLiteral{Value: n.Value}
default:
panic(fmt.Sprintf("cannot transform semantic node of type %T to an ast node", n))
}
} | semantic/ast.go | 0.506591 | 0.568416 | ast.go | starcoder |
package dfs
import (
"bytes"
"fmt"
)
func CircleDetect(m map[string]string) error {
g := NewGraph(m)
g.dfsAll()
if circles := g.Circles(); len(circles) > 0 {
return fmt.Errorf("circled on %v", g.Circles())
}
return nil
}
// the search path begin from a node, util END or CIRCLED
// 1. searched path
// 2. if the path contains a circle or a subcircle
func PathFromNode(m map[string]string, start string) ([]string, bool) {
g := NewGraph(m)
return g.dfs4path(start, nil)
}
// all search path to a node
func AllPathsToNode(m map[string]string, end string) [][]string {
ret := make([][]string, 0)
for k := range m {
path, circled := PathFromNode(m, k)
if !circled && len(path) > 1 { // ignore circled path & one element path
if idx := index(path, end); idx > 0 { // the path contains the step we expect
// ret = append(ret, path[:idx+1])
ret = append(ret, path[:idx])
fmt.Println(end, "is @", idx, "of", path, "cut the path:", path[:idx])
}
}
}
return ret
}
/*
Not Allowed: A -> B, A -> C
Allowed: A -> B, B -> C, M -> C, N -> C
TODO: A -> [B, C]
*/
// 模拟一个有向图
// 启动一个节点只能指向一个方向的另外一个节点, 不能同时指向多个节点
// 否则涉及到多个闭环的检测问题
type graph struct {
// 使用Map来模拟这个有向图, 其中图中的每个节点只能有一个子节点
// 多个不同节点可以有相同的子节点, 也就是说一个子节点可以有多个不同的父节点
m map[string]string
// 如果使用 Map[string][]string 来模拟的话, 就可以实现一个节点包含多个子节点
c map[string][]string
}
func NewGraph(m map[string]string) *graph {
initMap := make(map[string]string)
if m != nil {
for k, v := range m {
initMap[k] = v
}
}
return &graph{
m: initMap,
c: make(map[string][]string),
}
}
func (g *graph) Circles() map[string][]string {
g.dfsAll()
return g.c
}
func (g *graph) String() string {
buf := bytes.NewBuffer(nil)
for k, v := range g.m {
buf.WriteString(k + " -> " + v + "\n")
}
return buf.String()
}
// detect all circles and put into graph.c
func (g *graph) dfsAll() {
if g == nil {
return
}
for src := range g.m {
circle := g.dfs4circle(src, src, nil)
if len(circle) > 0 {
g.c[src] = circle
}
}
}
// 如果有多个闭环怎么办 ?
// 指定一个节点`start`, 开始深度搜索直至最后发生闭环或搜索结束.
// 第一个返回值是发生闭环的路径
// 第二个返回值是走过的所有路径 (不论是否发生闭环)
func (g *graph) dfs4circle(start, current string, stacks []string) []string {
// check if walked by
for _, step := range stacks {
if current == step { // circled, has been walked by
if current == start { // full circled @ `start`
return append(stacks, current)
}
return nil // sub circled @ any-walked-other-node
}
}
dst, ok := g.m[current]
if !ok { // search end // 搜索结束
return nil
}
// add a walk step
walked := append(stacks, current)
// walk to deeper
return g.dfs4circle(start, dst, walked)
}
// 指定一个起点`start`, 将整个搜索路径打印出来(非闭环)
// 起点`start`不能是闭环的, 否则将死循环无法退出
func (g *graph) dfs4path(start string, stacks []string) ([]string, bool) {
// check if walked by
for _, step := range stacks {
if start == step { // circled, no matter circle at `start` or any where
return append(stacks, start), true
}
}
dst, ok := g.m[start]
if !ok { // search end
return append(stacks, start), false
}
// add a walk step
walked := append(stacks, start)
// walk to deeper
return g.dfs4path(dst, walked)
}
func index(a []string, b string) int {
for idx, v := range a {
if v == b {
return idx
}
}
return -1
} | dfs-find-circle/dfs-find-circle.go | 0.503906 | 0.409221 | dfs-find-circle.go | starcoder |
package gohome
import (
"github.com/PucklaMotzer09/mathgl/mgl32"
"image/color"
)
// The color in which the shapes will be drawn
var DrawColor color.Color = Color{255, 255, 255, 255}
// The point size which will be used
var PointSize float32 = 1.0
// The line width which will be used
var LineWidth float32 = 1.0
// Wether the shapes should be filled
var Filled bool = true
// The detail of the curcle. The higher the more detailed
var CircleDetail int = 30
// Draws a point to point
func DrawPoint2D(point mgl32.Vec2) {
point2D := toPoint2D(point)
var robj Shape2D
robj.Init()
robj.SetPointSize(PointSize)
robj.SetLineWidth(LineWidth)
robj.AddPoints([]Shape2DVertex{point2D})
robj.Load()
RenderMgr.RenderRenderObject(&robj)
robj.Terminate()
}
// Draws a 2D line from pos1 to pos2
func DrawLine2D(pos1, pos2 mgl32.Vec2) {
line := toLine2D(pos1, pos2)
var robj Shape2D
robj.Init()
robj.AddLines([]Line2D{line})
robj.Load()
robj.SetDrawMode(DRAW_MODE_LINES)
RenderMgr.RenderRenderObject(&robj)
robj.Terminate()
}
// Draws a 2D triangle between pos1, pos2 and pos3
func DrawTriangle2D(pos1, pos2, pos3 mgl32.Vec2) {
tri := toTriangle2D(pos1, pos2, pos3)
var robj Shape2D
robj.Init()
if Filled {
robj.AddTriangles([]Triangle2D{tri})
robj.SetDrawMode(DRAW_MODE_TRIANGLES)
} else {
robj.AddLines(tri.ToLines())
robj.SetDrawMode(DRAW_MODE_LINES)
}
robj.Load()
RenderMgr.RenderRenderObject(&robj)
robj.Terminate()
}
// Draws a 2D rectangle between pos1,pos2,pos3 and pos4
func DrawRectangle2D(pos1, pos2, pos3, pos4 mgl32.Vec2) {
rect := toRectangle2D(pos1, pos2, pos3, pos4)
var robj Shape2D
robj.Init()
if Filled {
tris := rect.ToTriangles()
robj.AddTriangles(tris[:])
robj.SetDrawMode(DRAW_MODE_TRIANGLES)
} else {
robj.AddLines(rect.ToLines())
robj.SetDrawMode(DRAW_MODE_LINES)
}
robj.Load()
RenderMgr.RenderRenderObject(&robj)
robj.Terminate()
}
// Draws a 2D circle with pos as the middle with radius
func DrawCircle2D(pos mgl32.Vec2, radius float32) {
circle := Circle2D{
pos,
radius,
DrawColor,
}
var robj Shape2D
robj.Init()
if Filled {
robj.AddTriangles(circle.ToTriangles(CircleDetail))
robj.SetDrawMode(DRAW_MODE_TRIANGLES)
} else {
robj.AddLines(circle.ToLines(CircleDetail))
robj.SetDrawMode(DRAW_MODE_LINES)
}
robj.Load()
RenderMgr.RenderRenderObject(&robj)
robj.Terminate()
}
// Draws a polygon with positions
func DrawPolygon2D(positions ...mgl32.Vec2) {
if len(positions) < 3 {
ErrorMgr.Error("Polygon2D", "Draw", "Cannot draw polygon with less than 3 vertices")
return
}
poly := toPolygon2D(positions...)
var robj Shape2D
robj.Init()
if Filled {
robj.AddTriangles(poly.ToTriangles())
robj.SetDrawMode(DRAW_MODE_TRIANGLES)
} else {
robj.AddLines(poly.ToLines())
robj.SetDrawMode(DRAW_MODE_LINES)
}
robj.Load()
RenderMgr.RenderRenderObject(&robj)
robj.Terminate()
}
// Draws a texture to [x,y]
func DrawTexture(tex Texture, x, y int) {
DrawTextureAdv(tex, x, y, tex.GetWidth(), tex.GetHeight(), TextureRegion{
Min: [2]float32{0.0, 0.0},
Max: [2]float32{float32(tex.GetWidth()), float32(tex.GetHeight())},
},
FLIP_NONE)
}
// Draws a specific region of the texture with a flip
func DrawTextureAdv(tex Texture, x, y, width, height int, texReg TextureRegion, flip uint8) {
var spr Sprite2D
spr.InitTexture(tex)
spr.Transform.Position[0] = float32(x)
spr.Transform.Position[1] = float32(y)
spr.Transform.Size[0] = float32(width)
spr.Transform.Size[1] = float32(height)
spr.TextureRegion = texReg
spr.Flip = flip
RenderMgr.RenderRenderObject(&spr)
}
// Draws a 3D point
func DrawPoint3D(pos mgl32.Vec3) {
point := toVertex3D(pos)
var robj Shape3D
robj.Init()
robj.AddPoint(point)
robj.Load()
robj.SetDrawMode(DRAW_MODE_POINTS)
RenderMgr.RenderRenderObject(&robj)
robj.Terminate()
}
// Draws a 3D line from pos1 to pos2
func DrawLine3D(pos1, pos2 mgl32.Vec3) {
line := toLine3D(pos1, pos2)
var robj Shape3D
robj.Init()
robj.AddLine(line)
robj.Load()
robj.SetDrawMode(DRAW_MODE_LINES)
RenderMgr.RenderRenderObject(&robj)
robj.Terminate()
}
// Draws a triangle between pos1,pos2 and pos3
func DrawTriangle3D(pos1, pos2, pos3 mgl32.Vec3) {
tri := toTriangle3D(pos1, pos2, pos3)
var robj Shape3D
robj.Init()
robj.AddTriangle(tri)
robj.Load()
robj.SetDrawMode(DRAW_MODE_TRIANGLES)
RenderMgr.RenderRenderObject(&robj)
robj.Terminate()
}
// Draws a cube with pos as the middle and with,height and depth
// pitch, yaw and roll defines the rotation in degrees
func DrawCube(pos mgl32.Vec3, width, height, depth, pitch, yaw, roll float32) {
tris := cubeToTriangle3Ds(width, height, depth)
var robj Shape3D
robj.Init()
robj.AddTriangles(tris[:])
robj.Load()
robj.SetDrawMode(DRAW_MODE_TRIANGLES)
robj.Transform.Position = pos
pitch, yaw, roll = mgl32.DegToRad(pitch), mgl32.DegToRad(yaw), mgl32.DegToRad(roll)
robj.Transform.Rotation = mgl32.QuatRotate(pitch, [3]float32{1.0, 0.0, 0.0}).Mul(mgl32.QuatRotate(yaw, [3]float32{0.0, 1.0, 0.0})).Mul(mgl32.QuatRotate(roll, [3]float32{0.0, 0.0, 1.0}))
RenderMgr.RenderRenderObject(&robj)
robj.Terminate()
} | src/gohome/drawfunctions.go | 0.721841 | 0.436442 | drawfunctions.go | starcoder |
package math
import (
"container/heap"
"github.com/ava-labs/avalanchego/ids"
)
var (
_ AveragerHeap = averagerHeap{}
_ heap.Interface = &averagerHeapBackend{}
)
// AveragerHeap maintains a heap of the averagers.
type AveragerHeap interface {
// Add the average to the heap. If [nodeID] is already in the heap, the
// average will be replaced and the old average will be returned. If there
// was not an old average, false will be returned.
Add(nodeID ids.NodeID, averager Averager) (Averager, bool)
// Remove attempts to remove the average that was added with the provided
// [nodeID], if none is contained in the heap, [false] will be returned.
Remove(nodeID ids.NodeID) (Averager, bool)
// Pop attempts to remove the node with either the largest or smallest
// average, depending on if this is a max heap or a min heap, respectively.
Pop() (ids.NodeID, Averager, bool)
// Peek attempts to return the node with either the largest or smallest
// average, depending on if this is a max heap or a min heap, respectively.
Peek() (ids.NodeID, Averager, bool)
// Len returns the number of nodes that are currently in the heap.
Len() int
}
type averagerHeapEntry struct {
nodeID ids.NodeID
averager Averager
index int
}
type averagerHeapBackend struct {
isMaxHeap bool
nodeIDToEntry map[ids.NodeID]*averagerHeapEntry
entries []*averagerHeapEntry
}
type averagerHeap struct {
b *averagerHeapBackend
}
// NewMinAveragerHeap returns a new empty min heap. The returned heap is not
// thread safe.
func NewMinAveragerHeap() AveragerHeap {
return averagerHeap{b: &averagerHeapBackend{
nodeIDToEntry: make(map[ids.NodeID]*averagerHeapEntry),
}}
}
// NewMaxAveragerHeap returns a new empty max heap. The returned heap is not
// thread safe.
func NewMaxAveragerHeap() AveragerHeap {
return averagerHeap{b: &averagerHeapBackend{
isMaxHeap: true,
nodeIDToEntry: make(map[ids.NodeID]*averagerHeapEntry),
}}
}
func (h averagerHeap) Add(nodeID ids.NodeID, averager Averager) (Averager, bool) {
if e, exists := h.b.nodeIDToEntry[nodeID]; exists {
oldAverager := e.averager
e.averager = averager
heap.Fix(h.b, e.index)
return oldAverager, true
}
heap.Push(h.b, &averagerHeapEntry{
nodeID: nodeID,
averager: averager,
})
return nil, false
}
func (h averagerHeap) Remove(nodeID ids.NodeID) (Averager, bool) {
e, exists := h.b.nodeIDToEntry[nodeID]
if !exists {
return nil, false
}
heap.Remove(h.b, e.index)
return e.averager, true
}
func (h averagerHeap) Pop() (ids.NodeID, Averager, bool) {
if len(h.b.entries) == 0 {
return ids.EmptyNodeID, nil, false
}
e := h.b.entries[0]
heap.Pop(h.b)
return e.nodeID, e.averager, true
}
func (h averagerHeap) Peek() (ids.NodeID, Averager, bool) {
if len(h.b.entries) == 0 {
return ids.EmptyNodeID, nil, false
}
e := h.b.entries[0]
return e.nodeID, e.averager, true
}
func (h averagerHeap) Len() int {
return len(h.b.entries)
}
func (h *averagerHeapBackend) Len() int { return len(h.entries) }
func (h *averagerHeapBackend) Less(i, j int) bool {
if h.isMaxHeap {
return h.entries[i].averager.Read() > h.entries[j].averager.Read()
}
return h.entries[i].averager.Read() < h.entries[j].averager.Read()
}
func (h *averagerHeapBackend) Swap(i, j int) {
h.entries[i], h.entries[j] = h.entries[j], h.entries[i]
h.entries[i].index = i
h.entries[j].index = j
}
func (h *averagerHeapBackend) Push(x interface{}) {
e := x.(*averagerHeapEntry)
e.index = len(h.entries)
h.nodeIDToEntry[e.nodeID] = e
h.entries = append(h.entries, e)
}
func (h *averagerHeapBackend) Pop() interface{} {
newLen := len(h.entries) - 1
e := h.entries[newLen]
delete(h.nodeIDToEntry, e.nodeID)
h.entries = h.entries[:newLen]
return e
} | utils/math/averager_heap.go | 0.662906 | 0.479808 | averager_heap.go | starcoder |
package prque
import (
"container/heap"
"time"
"github.com/entropyio/go-entropy/common/timeutil"
)
// LazyQueue is a priority queue data structure where priorities can change over
// time and are only evaluated on demand.
// Two callbacks are required:
// - priority evaluates the actual priority of an item
// - maxPriority gives an upper estimate for the priority in any moment between
// now and the given absolute time
// If the upper estimate is exceeded then Update should be called for that item.
// A global Refresh function should also be called periodically.
type LazyQueue struct {
clock timeutil.Clock
// Items are stored in one of two internal queues ordered by estimated max
// priority until the next and the next-after-next refresh. Update and Refresh
// always places items in queue[1].
queue [2]*sstack
popQueue *sstack
period time.Duration
maxUntil timeutil.AbsTime
indexOffset int
setIndex SetIndexCallback
priority PriorityCallback
maxPriority MaxPriorityCallback
}
type (
PriorityCallback func(data interface{}, now timeutil.AbsTime) int64 // actual priority callback
MaxPriorityCallback func(data interface{}, until timeutil.AbsTime) int64 // estimated maximum priority callback
)
// NewLazyQueue creates a new lazy queue
func NewLazyQueue(setIndex SetIndexCallback, priority PriorityCallback, maxPriority MaxPriorityCallback, clock timeutil.Clock, refreshPeriod time.Duration) *LazyQueue {
q := &LazyQueue{
popQueue: newSstack(nil),
setIndex: setIndex,
priority: priority,
maxPriority: maxPriority,
clock: clock,
period: refreshPeriod}
q.Reset()
q.Refresh()
return q
}
// Reset clears the contents of the queue
func (q *LazyQueue) Reset() {
q.queue[0] = newSstack(q.setIndex0)
q.queue[1] = newSstack(q.setIndex1)
}
// Refresh should be called at least with the frequency specified by the refreshPeriod parameter
func (q *LazyQueue) Refresh() {
q.maxUntil = q.clock.Now() + timeutil.AbsTime(q.period)
for q.queue[0].Len() != 0 {
q.Push(heap.Pop(q.queue[0]).(*item).value)
}
q.queue[0], q.queue[1] = q.queue[1], q.queue[0]
q.indexOffset = 1 - q.indexOffset
q.maxUntil += timeutil.AbsTime(q.period)
}
// Push adds an item to the queue
func (q *LazyQueue) Push(data interface{}) {
heap.Push(q.queue[1], &item{data, q.maxPriority(data, q.maxUntil)})
}
// Update updates the upper priority estimate for the item with the given queue index
func (q *LazyQueue) Update(index int) {
q.Push(q.Remove(index))
}
// Pop removes and returns the item with the greatest actual priority
func (q *LazyQueue) Pop() (interface{}, int64) {
var (
resData interface{}
resPri int64
)
q.MultiPop(func(data interface{}, priority int64) bool {
resData = data
resPri = priority
return false
})
return resData, resPri
}
// peekIndex returns the index of the internal queue where the item with the
// highest estimated priority is or -1 if both are empty
func (q *LazyQueue) peekIndex() int {
if q.queue[0].Len() != 0 {
if q.queue[1].Len() != 0 && q.queue[1].blocks[0][0].priority > q.queue[0].blocks[0][0].priority {
return 1
}
return 0
}
if q.queue[1].Len() != 0 {
return 1
}
return -1
}
// MultiPop pops multiple items from the queue and is more efficient than calling
// Pop multiple times. Popped items are passed to the callback. MultiPop returns
// when the callback returns false or there are no more items to pop.
func (q *LazyQueue) MultiPop(callback func(data interface{}, priority int64) bool) {
now := q.clock.Now()
nextIndex := q.peekIndex()
for nextIndex != -1 {
data := heap.Pop(q.queue[nextIndex]).(*item).value
heap.Push(q.popQueue, &item{data, q.priority(data, now)})
nextIndex = q.peekIndex()
for q.popQueue.Len() != 0 && (nextIndex == -1 || q.queue[nextIndex].blocks[0][0].priority < q.popQueue.blocks[0][0].priority) {
i := heap.Pop(q.popQueue).(*item)
if !callback(i.value, i.priority) {
for q.popQueue.Len() != 0 {
q.Push(heap.Pop(q.popQueue).(*item).value)
}
return
}
}
}
}
// PopItem pops the item from the queue only, dropping the associated priority value.
func (q *LazyQueue) PopItem() interface{} {
i, _ := q.Pop()
return i
}
// Remove removes removes the item with the given index.
func (q *LazyQueue) Remove(index int) interface{} {
if index < 0 {
return nil
}
return heap.Remove(q.queue[index&1^q.indexOffset], index>>1).(*item).value
}
// Empty checks whether the priority queue is empty.
func (q *LazyQueue) Empty() bool {
return q.queue[0].Len() == 0 && q.queue[1].Len() == 0
}
// Size returns the number of items in the priority queue.
func (q *LazyQueue) Size() int {
return q.queue[0].Len() + q.queue[1].Len()
}
// setIndex0 translates internal queue item index to the virtual index space of LazyQueue
func (q *LazyQueue) setIndex0(data interface{}, index int) {
if index == -1 {
q.setIndex(data, -1)
} else {
q.setIndex(data, index+index)
}
}
// setIndex1 translates internal queue item index to the virtual index space of LazyQueue
func (q *LazyQueue) setIndex1(data interface{}, index int) {
q.setIndex(data, index+index+1)
} | common/prque/lazyqueue.go | 0.693369 | 0.400896 | lazyqueue.go | starcoder |
// Package fifo models the First-In-First-Out position management
// to calculate results of algorithmic trading by trade signals,
// given that returns are not reinvested and positions are not rebalanced.
package fifo
// Asset for the results of simulated trading
type Asset struct {
// Bar ID, e.g. date/time stamp, in any convenient format, not unique values are allowed
Bar string
// Underlying asset's prices
Pxs Prices
// Results for each side of bet are considered separately
// The Short side
S Position
// The Long side
L Position
// Cumulative return
CumReturn float64
// A flag indicating that an exit trade is blocked due to a possible loss
Block bool
// Net Asset Value
NAV float64
// Maximal NAV attained
MaxNAV float64
Drawdown float64
// Worst (maximum) drawdown
WDD float64
// Trade entry counter
EntryN int
// Trade exit counter
ExitN int
}
// Position for calculated results - comprehensive, spreadsheet-like
type Position struct {
// The size of position (In-Out-Ending)
Pos IOE
// The quantity of shares in position
Qty Tally
// The basis of position
Basis Tally
// The net market value of position
Val float64
// FIFO queue
Queue []Pending
// Net cash flow, net proceeds
NetCF Tally
// The results of trading
Result TReturn
}
// IOE for signals (In-Out-End)
type IOE struct {
// The size of a new bet (an addition to the position), entry signal
I int
// The size of removed position, exit signal
O int
// The resulting size of position
E int
}
// Prices for Close (Last) and Trade prices
type Prices struct {
// Close (last) price
Cl float64
// Trade price
Tx float64
}
// Tally describes changing amounts or values
type Tally struct {
// The starting amount
Sta float64
// The added (In) amount
I float64
// The removed (Out) amount
O float64
// The Variance (change) of amount
V float64
// The Ending amount
E float64
}
// TReturn describes trading returns
type TReturn struct {
// The Unrealized (Mark-to-Market) result
Unr float64
// The change of unrealized (Mark-to-Market) result
UnrChg float64
// The Realized result
Rzd float64
// The Total (Realized + Unrealized) result
Tot float64
}
// argsFIFO holds arguments for the fifo() function.
type argsFIFO struct {
// Prices and signals
Sigs []Trades
// Cash base (Cash Allocated for Trading) - assets initially allocated for
// the trading program
Cashbase float64
// Cash limit of exposure per position
Lim float64
// Broker's commission
Fee float64
}
// fifo calculates results of model trade on the basis of signals.
// Note: no error handling.
func fifo(q argsFIFO) (values []Asset, err error) {
var (
this Asset
)
// Allocate space for a slice of trade results
values = make([]Asset, len(q.Sigs))
for i, signals := range q.Sigs {
// Put underlying asset's prices into the Asset object
this.prices(signals)
if i == 0 {
// Initial signals (bar 1)
this.iniSignals(signals)
this.qtyStart(Asset{})
this.basisStart(Asset{})
this.additions(Asset{}, q)
this.qtyEnd()
this.basisEnd()
// Starting Net Asset Value
this.NAV = q.Cashbase
}
if i > 0 {
// Put the signals into the Asset object
this.signals(signals, values[i-1])
// Ending position size
this.posEnd(values[i-1])
// Starting quantity
this.qtyStart(values[i-1])
// Starting basis
this.basisStart(values[i-1])
// New trades, opened positions
this.additions(values[i-1], q)
// Closed positions
this.removals(values[i-1])
// Ending quantity
this.qtyEnd()
// Ending basis
this.basisEnd()
// Mark to Market
this.mtm()
// Net proceeds from position removal, closing an exact number of
// positions
this.cfRemov(q.Fee)
// Returns
this.returns(values[i-1])
// Net Asset Value
this.assets(q.Cashbase)
// Peak Net Asset Value
this.maxAssets(values[i-1])
// Drawdown
this.drawdown(q.Cashbase)
// Worst (maximum) drawdown
this.wdd(values[i-1])
// Number of trades
// The counter of additions (initiated trades)
this.countEntries()
// The counter of removals (completed trades)
this.countExits()
}
values[i] = this
}
return
} | fifo/fifo.go | 0.559771 | 0.47384 | fifo.go | starcoder |
package kal
import (
"errors"
"time"
)
// Calendar provides a common interface for calendars of all languages
// and locales
type Calendar interface {
DayName(time.Weekday) string
RedDay(time.Time) (bool, string, bool)
NotableDay(time.Time) (bool, string, bool)
NormalDay() string
NotablePeriod(time.Time) (bool, string)
MonthName(time.Month) string
MondayFirst() bool
}
/* Create a new calendar based on a given language string.
*
* Supported strings:
* nb_NO (Norwegian Bokmål)
* en_US (US English)
* tr_TR (Turkish)
*
* The calendar can be cached for faster lookups
*/
func NewCalendar(locCode string, cache bool) (cal Calendar, err error) {
// Find the corresponding calendar struct for the given locale
switch locCode {
case "nb_NO":
cal = NewNorwegianCalendar()
case "en_US":
cal = NewUSCalendar()
case "tr_TR":
cal = NewTRCalendar()
default:
return cal, errors.New("Locale not supported: " + locCode)
}
if cache {
// Return a calendar with cache
return NewCachedCalendar(cal), nil
}
return cal, nil
}
// Returns the third boolean argument given a time.Time value and
// a function that takes a time.Time and returns a bool, a string and a bool
func thirdBool(date time.Time, fn func(time.Time) (bool, string, bool)) bool {
_, _, b := fn(date)
return b
}
// Checks if a given date is a flag flying day or not
func FlagDay(cal Calendar, date time.Time) bool {
return thirdBool(date, cal.RedDay) || thirdBool(date, cal.NotableDay)
}
// Checks if a given date is a "red" day or not
func RedDay(cal Calendar, date time.Time) bool {
return thirdBool(date, cal.RedDay)
}
// Checks if a given date is a notable day or not
func NotableDay(cal Calendar, date time.Time) bool {
return thirdBool(date, cal.NotableDay)
}
// Describe what type of day a given date is
func Describe(cal Calendar, date time.Time) string {
fulldesc := ""
if red, desc, _ := cal.RedDay(date); red {
fulldesc = desc
}
if notable, desc, _ := cal.NotableDay(date); notable {
if fulldesc == "" {
fulldesc = desc
} else {
fulldesc += ", " + desc
}
}
if fulldesc != "" {
return fulldesc
}
return cal.NormalDay()
}
// Return a space separated string of the two first letters of every weekday
func TwoLetterDays(cal Calendar, mondayFirst bool) string {
var (
i time.Weekday
s string
)
if !mondayFirst {
for i = 0; i < 7; i++ {
if i != 0 {
s += " "
}
s += string([]rune(cal.DayName(i))[:2])
}
} else {
for i = 1; i < 7; i++ {
if i != 1 {
s += " "
}
s += string([]rune(cal.DayName(i))[:2])
}
s += " " + string([]rune(cal.DayName(time.Weekday(0)))[:2])
}
return s
}
// Get the week number, from 1 to 53
func WeekNum(date time.Time) int {
_, weeknum := date.ISOWeek()
return weeknum
} | calendar.go | 0.70304 | 0.459137 | calendar.go | starcoder |
package iso20022
// Specifies the balance adjustments for a specific service.
type BalanceAdjustment1 struct {
// Identifies the type of adjustment.
Type *BalanceAdjustmentType1Code `xml:"Tp"`
// Free-form description and clarification of the adjustment.
Description *Max105Text `xml:"Desc"`
// Amount of the adjustment. If the amount would reduce the underlying balance then the amount should be negatively signed. Expressed in the Account currency.
BalanceAmount *AmountAndDirection34 `xml:"BalAmt"`
// Day-weighted net amount of the adjustment to the average collected balance over the statement period.
AverageAmount *AmountAndDirection34 `xml:"AvrgAmt,omitempty"`
// Date on which the error occurred in the underlying cash account.
ErrorDate *ISODate `xml:"ErrDt,omitempty"`
// Date on which the error was corrected in the cash account. If the date is not know then use the last day of the month in which the error was corrected.
PostingDate *ISODate `xml:"PstngDt"`
// Number of days within the period to which the adjustment applies.
Days *DecimalNumber `xml:"Days,omitempty"`
// Earnings credit adjustment, debit or credit, resulting from this adjustment’s effect on the average collected balance. If the amount would reduce the credit due then the amount should be negatively signed.
EarningsAdjustmentAmount *AmountAndDirection34 `xml:"EarngsAdjstmntAmt,omitempty"`
}
func (b *BalanceAdjustment1) SetType(value string) {
b.Type = (*BalanceAdjustmentType1Code)(&value)
}
func (b *BalanceAdjustment1) SetDescription(value string) {
b.Description = (*Max105Text)(&value)
}
func (b *BalanceAdjustment1) AddBalanceAmount() *AmountAndDirection34 {
b.BalanceAmount = new(AmountAndDirection34)
return b.BalanceAmount
}
func (b *BalanceAdjustment1) AddAverageAmount() *AmountAndDirection34 {
b.AverageAmount = new(AmountAndDirection34)
return b.AverageAmount
}
func (b *BalanceAdjustment1) SetErrorDate(value string) {
b.ErrorDate = (*ISODate)(&value)
}
func (b *BalanceAdjustment1) SetPostingDate(value string) {
b.PostingDate = (*ISODate)(&value)
}
func (b *BalanceAdjustment1) SetDays(value string) {
b.Days = (*DecimalNumber)(&value)
}
func (b *BalanceAdjustment1) AddEarningsAdjustmentAmount() *AmountAndDirection34 {
b.EarningsAdjustmentAmount = new(AmountAndDirection34)
return b.EarningsAdjustmentAmount
} | BalanceAdjustment1.go | 0.828939 | 0.4953 | BalanceAdjustment1.go | starcoder |
package bitmap
import (
"image"
"github.com/pzduniak/unipdf/common"
)
// CombineBytes combines the provided bytes with respect to the CombinationOperator.
func CombineBytes(oldByte, newByte byte, op CombinationOperator) byte {
return combineBytes(oldByte, newByte, op)
}
// Extract extracts the rectangle of given size from the source 'src' Bitmap.
func Extract(roi image.Rectangle, src *Bitmap) (*Bitmap, error) {
dst := New(roi.Dx(), roi.Dy())
upShift := roi.Min.X & 0x07
downShift := 8 - upShift
padding := uint(8 - dst.Width&0x07)
srcLineStartIdx := src.GetByteIndex(roi.Min.X, roi.Min.Y)
srcLineEndIdx := src.GetByteIndex(roi.Max.X-1, roi.Min.Y)
usePadding := dst.RowStride == srcLineEndIdx+1-srcLineStartIdx
var dstLineStartIdx int
for y := roi.Min.Y; y < roi.Max.Y; y++ {
srcIdx := srcLineStartIdx
dstIdx := dstLineStartIdx
if srcLineStartIdx == srcLineEndIdx {
pixels, err := src.GetByte(srcIdx)
if err != nil {
return nil, err
}
pixels <<= uint(upShift)
err = dst.SetByte(dstIdx, unpad(padding, pixels))
if err != nil {
return nil, err
}
} else if upShift == 0 {
for x := srcLineStartIdx; x <= srcLineEndIdx; x++ {
value, err := src.GetByte(srcIdx)
if err != nil {
return nil, err
}
srcIdx++
if x == srcLineEndIdx && usePadding {
value = unpad(padding, value)
}
err = dst.SetByte(dstIdx, value)
if err != nil {
return nil, err
}
dstIdx++
}
} else {
err := copyLine(src, dst, uint(upShift), uint(downShift), padding, srcLineStartIdx, srcLineEndIdx, usePadding, srcIdx, dstIdx)
if err != nil {
return nil, err
}
}
srcLineStartIdx += src.RowStride
srcLineEndIdx += src.RowStride
dstLineStartIdx += dst.RowStride
}
return dst, nil
}
func combineBytes(oldByte, newByte byte, op CombinationOperator) byte {
switch op {
case CmbOpOr:
return newByte | oldByte
case CmbOpAnd:
return newByte & oldByte
case CmbOpXor:
return newByte ^ oldByte
case CmbOpXNor:
return ^(newByte ^ oldByte)
case CmbOpNot:
return ^(newByte)
default:
return newByte
}
}
func copyLine(
src, dst *Bitmap,
sourceUpShift, sourceDownShift, padding uint,
firstSourceByteOfLine, lastSourceByteOfLine int,
usePadding bool, sourceOffset, targetOffset int,
) error {
for x := firstSourceByteOfLine; x < lastSourceByteOfLine; x++ {
if sourceOffset+1 < len(src.Data) {
isLastByte := x+1 == lastSourceByteOfLine
v1, err := src.GetByte(sourceOffset)
if err != nil {
return err
}
sourceOffset++
v1 <<= sourceUpShift
v2, err := src.GetByte(sourceOffset)
if err != nil {
return err
}
v2 >>= sourceDownShift
value := v1 | v2
if isLastByte && !usePadding {
value = unpad(padding, value)
}
err = dst.SetByte(targetOffset, value)
if err != nil {
return err
}
targetOffset++
if isLastByte && usePadding {
temp, err := src.GetByte(sourceOffset)
if err != nil {
return err
}
temp <<= sourceUpShift
value = unpad(padding, temp)
if err = dst.SetByte(targetOffset, value); err != nil {
return err
}
}
continue
}
value, err := src.GetByte(sourceOffset)
if err != nil {
common.Log.Debug("Getting the value at: %d failed: %s", sourceOffset, err)
return err
}
value <<= sourceUpShift
sourceOffset++
err = dst.SetByte(targetOffset, value)
if err != nil {
return err
}
targetOffset++
}
return nil
} | bot/vendor/github.com/pzduniak/unipdf/internal/jbig2/bitmap/combine.go | 0.652463 | 0.413714 | combine.go | starcoder |
package api
import "fmt"
// Equalizer represents an equalizer. A list of possible equalizers are
// available when requesting product info.
type Equalizer int
// Equalizer enums.
// {"data": {"type": 0, "value": 12}, "msg": "EQ_SETTING"}
const (
EqualizerStandard Equalizer = 0
EqualizerBass Equalizer = 1
EqualizerFlat Equalizer = 2
EqualizerBoost Equalizer = 3
EqualizerTrebleBass Equalizer = 4
EqualizerUser Equalizer = 5
EqualizerMusic Equalizer = 6
EqualizerCinema Equalizer = 7
EqualizerNight Equalizer = 8
EqualizerNews Equalizer = 9
EqualizerVoice Equalizer = 10
EqualizerISound Equalizer = 11
EqualizerASC Equalizer = 12
EqualizerMovie Equalizer = 13
EqualizerBassBlast Equalizer = 14
EqualizerDolbyAtmos Equalizer = 15
EqualizerDTSVirtualX Equalizer = 16
EqualizerBassBoostPlus Equalizer = 17
)
func (e Equalizer) String() string {
switch e {
case EqualizerStandard:
return "Standard"
case EqualizerBass:
return "Bass"
case EqualizerFlat:
return "Flat"
case EqualizerBoost:
return "Boost"
case EqualizerTrebleBass:
return "Treble and Bass"
case EqualizerUser:
return "User"
case EqualizerMusic:
return "Music"
case EqualizerCinema:
return "Cinema"
case EqualizerNight:
return "Night"
case EqualizerNews:
return "News"
case EqualizerVoice:
return "Voice"
case EqualizerISound:
return "ISound"
case EqualizerASC:
return "ASC"
case EqualizerMovie:
return "Movie"
case EqualizerBassBlast:
return "Bass Blast"
case EqualizerDolbyAtmos:
return "D<NAME>"
case EqualizerDTSVirtualX:
return "DTS Virtual X"
case EqualizerBassBoostPlus:
return "Bass Boost Plus"
default:
return fmt.Sprintf("Equalizer(%d)", e)
}
}
// EqualizerType is a setting type for changing equalizer settings.
type EqualizerType int
// EqualizerType enums.
// {"data": {"type": 1, "value": 5}, "msg": "EQ_SETTING"}
// {"data": {"type": 3, "value": 20}, "msg": "EQ_SETTING"}
const (
SetEqualizer EqualizerType = 0 // Sets EQ, e.g. Cinema, ASC, etc.
SetBass EqualizerType = 1
SetTreble EqualizerType = 2
SetLeftRightBalance EqualizerType = 3
// Save or restore equalizer setting. Value 1 saves, 0 restores.
// Reads of EQ_INFO_REQ will echo the previously saved value
// until the new values are saved.
// 2021-04-17 Update: On firmware NB9.504.00629.C EQ_INFO_REQ
// seems to return the current value, saved or not.
SetSaveRestore EqualizerType = 4
)
func (t EqualizerType) String() string {
switch t {
case SetEqualizer:
return "Equalizer"
case SetBass:
return "Bass"
case SetTreble:
return "Treble"
case SetLeftRightBalance:
return "LeftRightBalance"
case SetSaveRestore:
return "SaveRestore"
default:
return fmt.Sprintf("EqualizerType(%d)", t)
}
}
// Function represents a function mode for the speaker. A list of
// available modes are available when requesting product info.
type Function int
// Function mode enums.
// {"data": {"type": 7}, "msg": "FUNCTION_SET"}
const (
FunctionWiFi Function = 0
FunctionBluetooth Function = 1
FunctionPortable Function = 2
FunctionAUX Function = 3
FunctionOptical Function = 4
FunctionCP Function = 5
FunctionHDMI Function = 6
FunctionARC Function = 7
FunctionSpotify Function = 8
FunctionOptical2 Function = 9
FunctionHDMI2 Function = 10
FunctionHDMI3 Function = 11
FunctionLGTV Function = 12
FunctionMic Function = 13
FunctionC4A Function = 14
FunctionOpticalARC Function = 15
FunctionLGOptical Function = 16
FunctionFM Function = 17
FunctionUSB Function = 18
)
func (f Function) String() string {
switch f {
case FunctionWiFi:
return "WiFi"
case FunctionBluetooth:
return "Bluetooth"
case FunctionPortable:
return "Portable"
case FunctionAUX:
return "AUX"
case FunctionOptical:
return "Optical"
case FunctionCP:
return "CP"
case FunctionHDMI:
return "HDMI"
case FunctionARC:
return "ARC"
case FunctionSpotify:
return "Spotify"
case FunctionOptical2:
return "Optical2"
case FunctionHDMI2:
return "HDMI2"
case FunctionHDMI3:
return "HDMI3"
case FunctionLGTV:
return "LGTV"
case FunctionMic:
return "Microphone"
case FunctionC4A:
return "C4A"
case FunctionOpticalARC:
return "Optical / HDMI ARC"
case FunctionLGOptical:
return "LG Optical"
case FunctionFM:
return "FM"
case FunctionUSB:
return "USB"
default:
return fmt.Sprintf("Function(%d)", f)
}
}
// Model represents the speaker model.
type Model int
// Model type (product info "modeltype") enums.
const (
ModelBridge Model = 0
ModelBasic Model = 1
ModelSoundBar Model = 2
ModelMono Model = 3
ModelConnector Model = 4
ModelPortable Model = 5
)
func (m Model) String() string {
switch m {
case ModelBridge:
return "Bridge"
case ModelBasic:
return "Basic"
case ModelSoundBar:
return "SoundBar"
case ModelMono:
return "Mono"
case ModelConnector:
return "Connector"
case ModelPortable:
return "Portable"
default:
return fmt.Sprintf("Model(%d)", m)
}
}
// Network represents the connection type.
type Network int
// Network type (product info "network") enums.
const (
NetworkWired Network = 0
NetworkWireless Network = 1
NetworkMeshed Network = 2
)
func (n Network) String() string {
switch n {
case NetworkWired:
return "Wired"
case NetworkWireless:
return "Wireless"
case NetworkMeshed:
return "Meshed"
default:
return fmt.Sprintf("Network(%d)", n)
}
}
// Role represents the speakers role.
type Role int
// Speaker role (product info "spktype") enums.
const (
RoleIndividual Role = 0
RoleMaster Role = 1
RoleSlave Role = 2
RoleSurroundMaster Role = 3
RoleSurroundSlave Role = 4
)
func (r Role) String() string {
switch r {
case RoleIndividual:
return "Individual"
case RoleMaster:
return "Master"
case RoleSlave:
return "Slave"
case RoleSurroundMaster:
return "Surround Master"
case RoleSurroundSlave:
return "Surround Slave"
default:
return fmt.Sprintf("Role(%d)", r)
}
} | api/enum.go | 0.644561 | 0.499084 | enum.go | starcoder |
package rogue
import (
"fmt"
"math"
"math/rand"
)
// Point ...
type Point struct {
X float64
Y float64
}
func (p Point) String() string {
return fmt.Sprintf("%f,%f", p.X, p.Y)
}
// Equals returns true of p and p2 has the same coordinates
func (p Point) Equals(p2 Point) bool {
if p.X == p2.X && p.Y == p2.Y {
return true
}
return false
}
func (o *Obj) distanceTo(pos *Point) float64 {
xd := o.Position.X - pos.X
yd := o.Position.Y - pos.Y
return math.Hypot(xd, yd)
}
func (p *Point) empty() bool {
// XXX
if p.X == 0 && p.Y == 0 {
return true
}
return false
}
func (p *Point) intMatches(t *Point) bool {
if math.Floor(p.X) == math.Floor(t.X) && math.Floor(p.Y) == math.Floor(t.Y) {
return true
}
return false
}
// select 3x3 square of positions around n.pos, pick one at random (never p)
func (o *Obj) randomNearby() (Point, error) {
var m []Point
p := o.Position
for y := p.Y - 1; y <= p.Y+1; y++ {
for x := p.X - 1; x <= p.X+1; x++ {
if y >= 0 && y < float64(o.Island.Height) && x >= 0 && x < float64(o.Island.Width) {
pp := Point{x, y}
if !pp.Equals(p) && o.Island.isAboveWater(pp) {
m = append(m, pp)
}
}
}
}
if len(m) == 0 {
empty := Point{}
return empty, fmt.Errorf("Cant find nearby points to %s", p)
}
// select something by random
return m[rand.Intn(len(m))], nil
}
func (p *Point) isNearby(pos Point) bool {
distance := float64(5)
absX := math.Abs(p.X - pos.X)
absY := math.Abs(p.Y - pos.Y)
if absX < distance && absY < distance {
return true
}
return false
}
func (o *Obj) spawnsByName(n string, radius float64) []*Obj {
var res []*Obj
for _, sp := range o.Island.Spawns {
if sp.Name == n && sp.distanceTo(&o.Position) <= radius {
res = append(res, sp)
}
}
return res
}
func (o *Obj) spawnsByType(t string, radius float64) []*Obj {
var res []*Obj
for _, sp := range o.Island.Spawns {
if sp.Type == t && sp.distanceTo(&o.Position) <= radius {
res = append(res, sp)
}
}
//log.Debugf("spawnsByType radius %f from %s match %s: found %d\n", radius, p, t, len(res))
return res
} | point.go | 0.78502 | 0.462291 | point.go | starcoder |
package evaluator
import (
"fmt"
"github.com/raa0121/GoBCDice/pkg/core/ast"
)
// DetermneValuesは、可変ノードの値を決定する
func (e *Evaluator) DetermineValues(node ast.Node) error {
switch n := node.(type) {
case *ast.Command:
return e.determineValuesInCommand(n)
case ast.PrefixExpression:
return e.determineValuesInPrefixExpression(n)
case ast.InfixExpression:
return e.determineValuesInInfixExpression(n)
}
return fmt.Errorf("DetermineValues not implemented: %s", node.Type())
}
func (e *Evaluator) determineValueOfVariableExpr(node ast.Node) (ast.Node, error) {
if node.Type() == ast.D_ROLL_NODE {
return e.determineValueOfDRoll(node.(*ast.VariableInfixExpression))
}
return nil, fmt.Errorf("determineValueOfVariableExpr not implemented: %s", node.Type())
}
func (e *Evaluator) determineValueOfDRoll(
node *ast.VariableInfixExpression,
) (*ast.SumRollResult, error) {
num, numIsInt := node.Left().(*ast.Int)
if !numIsInt {
return nil, fmt.Errorf("num is not Int: %s", node.Left().Type())
}
sides, sidesIsInt := node.Right().(*ast.Int)
if !sidesIsInt {
return nil, fmt.Errorf("sides is not Int: %s", node.Right().Type())
}
numVal := num.Value
sidesVal := sides.Value
rolledDice, rollDiceErr := e.RollDice(numVal, sidesVal)
if rollDiceErr != nil {
return nil, rollDiceErr
}
return ast.NewSumRollResult(rolledDice), nil
}
type nodeSetter func(ast.Node)
func (e *Evaluator) replaceVariablePrimaryExpr(node ast.Node, setter nodeSetter) error {
if node.IsVariable() {
valueDeterminedNode, err := e.determineValueOfVariableExpr(node)
if err != nil {
return err
}
setter(valueDeterminedNode)
}
return nil
}
func (e *Evaluator) determineValuesInCommand(node *ast.Command) error {
expr := node.Expression
if expr.IsPrimaryExpression() {
return e.replaceVariablePrimaryExpr(expr, func(newNode ast.Node) {
node.Expression = newNode
})
}
return e.DetermineValues(expr)
}
func (e *Evaluator) determineValuesInPrefixExpression(node ast.PrefixExpression) error {
right := node.Right()
if right.IsPrimaryExpression() {
return e.replaceVariablePrimaryExpr(right, func(newNode ast.Node) {
node.SetRight(newNode)
})
}
return e.DetermineValues(right)
}
func (e *Evaluator) determineValuesInInfixExpression(node ast.InfixExpression) error {
left := node.Left()
var leftErr error
if left.IsPrimaryExpression() {
leftErr = e.replaceVariablePrimaryExpr(left, func(newNode ast.Node) {
node.SetLeft(newNode)
})
} else {
leftErr = e.DetermineValues(left)
}
if leftErr != nil {
return leftErr
}
right := node.Right()
if right.IsPrimaryExpression() {
return e.replaceVariablePrimaryExpr(right, func(newNode ast.Node) {
node.SetRight(newNode)
})
}
return e.DetermineValues(right)
} | pkg/core/evaluator/determine_values.go | 0.653238 | 0.42471 | determine_values.go | starcoder |
package mlpack
/*
#cgo CFLAGS: -I./capi -Wall
#cgo LDFLAGS: -L. -lmlpack_go_sparse_coding
#include <capi/sparse_coding.h>
#include <stdlib.h>
*/
import "C"
import "gonum.org/v1/gonum/mat"
type SparseCodingOptionalParam struct {
Atoms int
InitialDictionary *mat.Dense
InputModel *sparseCoding
Lambda1 float64
Lambda2 float64
MaxIterations int
NewtonTolerance float64
Normalize bool
ObjectiveTolerance float64
Seed int
Test *mat.Dense
Training *mat.Dense
Verbose bool
}
func SparseCodingOptions() *SparseCodingOptionalParam {
return &SparseCodingOptionalParam{
Atoms: 15,
InitialDictionary: nil,
InputModel: nil,
Lambda1: 0,
Lambda2: 0,
MaxIterations: 0,
NewtonTolerance: 1e-06,
Normalize: false,
ObjectiveTolerance: 0.01,
Seed: 0,
Test: nil,
Training: nil,
Verbose: false,
}
}
/*
An implementation of Sparse Coding with Dictionary Learning, which achieves
sparsity via an l1-norm regularizer on the codes (LASSO) or an (l1+l2)-norm
regularizer on the codes (the Elastic Net). Given a dense data matrix X with
d dimensions and n points, sparse coding seeks to find a dense dictionary
matrix D with k atoms in d dimensions, and a sparse coding matrix Z with n
points in k dimensions.
The original data matrix X can then be reconstructed as Z * D. Therefore,
this program finds a representation of each point in X as a sparse linear
combination of atoms in the dictionary D.
The sparse coding is found with an algorithm which alternates between a
dictionary step, which updates the dictionary D, and a sparse coding step,
which updates the sparse coding matrix.
Once a dictionary D is found, the sparse coding model may be used to encode
other matrices, and saved for future usage.
To run this program, either an input matrix or an already-saved sparse coding
model must be specified. An input matrix may be specified with the "Training"
option, along with the number of atoms in the dictionary (specified with the
"Atoms" parameter). It is also possible to specify an initial dictionary for
the optimization, with the "InitialDictionary" parameter. An input model may
be specified with the "InputModel" parameter.
As an example, to build a sparse coding model on the dataset data using 200
atoms and an l1-regularization parameter of 0.1, saving the model into model,
use
// Initialize optional parameters for SparseCoding().
param := mlpack.SparseCodingOptions()
param.Training = data
param.Atoms = 200
param.Lambda1 = 0.1
_, _, model := mlpack.SparseCoding(param)
Then, this model could be used to encode a new matrix, otherdata, and save the
output codes to codes:
// Initialize optional parameters for SparseCoding().
param := mlpack.SparseCodingOptions()
param.InputModel = &model
param.Test = otherdata
codes, _, _ := mlpack.SparseCoding(param)
Input parameters:
- Atoms (int): Number of atoms in the dictionary. Default value 15.
- InitialDictionary (mat.Dense): Optional initial dictionary matrix.
- InputModel (sparseCoding): File containing input sparse coding
model.
- Lambda1 (float64): Sparse coding l1-norm regularization parameter.
Default value 0.
- Lambda2 (float64): Sparse coding l2-norm regularization parameter.
Default value 0.
- MaxIterations (int): Maximum number of iterations for sparse coding
(0 indicates no limit). Default value 0.
- NewtonTolerance (float64): Tolerance for convergence of Newton
method. Default value 1e-06.
- Normalize (bool): If set, the input data matrix will be normalized
before coding.
- ObjectiveTolerance (float64): Tolerance for convergence of the
objective function. Default value 0.01.
- Seed (int): Random seed. If 0, 'std::time(NULL)' is used. Default
value 0.
- Test (mat.Dense): Optional matrix to be encoded by trained model.
- Training (mat.Dense): Matrix of training data (X).
- Verbose (bool): Display informational messages and the full list of
parameters and timers at the end of execution.
Output parameters:
- codes (mat.Dense): Matrix to save the output sparse codes of the test
matrix (--test_file) to.
- dictionary (mat.Dense): Matrix to save the output dictionary to.
- outputModel (sparseCoding): File to save trained sparse coding model
to.
*/
func SparseCoding(param *SparseCodingOptionalParam) (*mat.Dense, *mat.Dense, sparseCoding) {
resetTimers()
enableTimers()
disableBacktrace()
disableVerbose()
restoreSettings("Sparse Coding")
// Detect if the parameter was passed; set if so.
if param.Atoms != 15 {
setParamInt("atoms", param.Atoms)
setPassed("atoms")
}
// Detect if the parameter was passed; set if so.
if param.InitialDictionary != nil {
gonumToArmaMat("initial_dictionary", param.InitialDictionary)
setPassed("initial_dictionary")
}
// Detect if the parameter was passed; set if so.
if param.InputModel != nil {
setSparseCoding("input_model", param.InputModel)
setPassed("input_model")
}
// Detect if the parameter was passed; set if so.
if param.Lambda1 != 0 {
setParamDouble("lambda1", param.Lambda1)
setPassed("lambda1")
}
// Detect if the parameter was passed; set if so.
if param.Lambda2 != 0 {
setParamDouble("lambda2", param.Lambda2)
setPassed("lambda2")
}
// Detect if the parameter was passed; set if so.
if param.MaxIterations != 0 {
setParamInt("max_iterations", param.MaxIterations)
setPassed("max_iterations")
}
// Detect if the parameter was passed; set if so.
if param.NewtonTolerance != 1e-06 {
setParamDouble("newton_tolerance", param.NewtonTolerance)
setPassed("newton_tolerance")
}
// Detect if the parameter was passed; set if so.
if param.Normalize != false {
setParamBool("normalize", param.Normalize)
setPassed("normalize")
}
// Detect if the parameter was passed; set if so.
if param.ObjectiveTolerance != 0.01 {
setParamDouble("objective_tolerance", param.ObjectiveTolerance)
setPassed("objective_tolerance")
}
// Detect if the parameter was passed; set if so.
if param.Seed != 0 {
setParamInt("seed", param.Seed)
setPassed("seed")
}
// Detect if the parameter was passed; set if so.
if param.Test != nil {
gonumToArmaMat("test", param.Test)
setPassed("test")
}
// Detect if the parameter was passed; set if so.
if param.Training != nil {
gonumToArmaMat("training", param.Training)
setPassed("training")
}
// Detect if the parameter was passed; set if so.
if param.Verbose != false {
setParamBool("verbose", param.Verbose)
setPassed("verbose")
enableVerbose()
}
// Mark all output options as passed.
setPassed("codes")
setPassed("dictionary")
setPassed("output_model")
// Call the mlpack program.
C.mlpackSparseCoding()
// Initialize result variable and get output.
var codesPtr mlpackArma
codes := codesPtr.armaToGonumMat("codes")
var dictionaryPtr mlpackArma
dictionary := dictionaryPtr.armaToGonumMat("dictionary")
var outputModel sparseCoding
outputModel.getSparseCoding("output_model")
// Clear settings.
clearSettings()
// Return output(s).
return codes, dictionary, outputModel
} | sparse_coding.go | 0.718693 | 0.573977 | sparse_coding.go | starcoder |
package blob
// Blob is a binary blob of data that can support platform-optimized mutations for better performance.
type Blob interface {
// Bytes returns the byte slice equivalent to the data in this Blob.
Bytes() []byte
// Len returns the number of bytes contained in this blob.
// Can be used to avoid unnecessary conversions and allocations from len(Bytes()).
Len() int
}
// ViewBlob is a Blob that can return a view into the same underlying data.
// Mutating the returned Blob also mutates the original.
type ViewBlob interface {
Blob
View(start, end int64) (Blob, error)
}
// SliceBlob is a Blob that can return a copy of the data between start and end.
type SliceBlob interface {
Blob
Slice(start, end int64) (Blob, error)
}
// SetBlob is a Blob that can copy 'src' into itself starting at the given offset into this Blob.
// Use View() on 'src' to control the maximum that is copied into this Blob.
type SetBlob interface {
Blob
Set(src Blob, offset int64) (n int, err error)
}
// GrowBlob is a Blob that can increase it's size by allocating offset bytes at the end.
type GrowBlob interface {
Blob
Grow(offset int64) error
}
// TruncateBlob is a Blob that can cut off bytes from the end until it is 'size' bytes long.
type TruncateBlob interface {
Blob
Truncate(size int64) error
}
// View attempts to call an optimized blob.View(), falls back to copying into Bytes and running Bytes.View().
func View(b Blob, start, end int64) (Blob, error) {
if b, ok := b.(ViewBlob); ok {
return b.View(start, end)
}
return NewBytes(b.Bytes()).View(start, end)
}
// Slice attempts to call an optimized blob.Slice(), falls back to copying into Bytes and running Bytes.Slice().
func Slice(b Blob, start, end int64) (Blob, error) {
if b, ok := b.(SliceBlob); ok {
return b.Slice(start, end)
}
return NewBytes(b.Bytes()).Slice(start, end)
}
// Set attempts to call an optimized blob.Set(), falls back to copying into Bytes and running Bytes.Set().
func Set(dest Blob, src Blob, offset int64) (n int, err error) {
if dest, ok := dest.(SetBlob); ok {
return dest.Set(src, offset)
}
return NewBytes(dest.Bytes()).Set(src, offset)
}
// Grow attempts to call an optimized blob.Grow(), falls back to copying into Bytes and running Bytes.Grow().
func Grow(b Blob, offset int64) error {
if b, ok := b.(GrowBlob); ok {
return b.Grow(offset)
}
return NewBytes(b.Bytes()).Grow(offset)
}
// Truncate attempts to call an optimized blob.Truncate(), falls back to copying into Bytes and running Bytes.Truncate().
func Truncate(b Blob, size int64) error {
if b, ok := b.(TruncateBlob); ok {
return b.Truncate(size)
}
return NewBytes(b.Bytes()).Truncate(size)
} | keyvalue/blob/blob.go | 0.865722 | 0.597608 | blob.go | starcoder |
package encoding
import (
"encoding"
"encoding/json"
"fmt"
"reflect"
"strconv"
)
func decodeToType(typ reflect.Kind, value string) interface{} {
switch typ {
case reflect.String:
return value
case reflect.Bool:
v, _ := strconv.ParseBool(value)
return v
case reflect.Int:
v, _ := strconv.ParseInt(value, 10, 64)
return int(v)
case reflect.Int8:
return int8(decodeToType(reflect.Int, value).(int))
case reflect.Int16:
return int16(decodeToType(reflect.Int, value).(int))
case reflect.Int32:
return int32(decodeToType(reflect.Int, value).(int))
case reflect.Int64:
return int64(decodeToType(reflect.Int, value).(int))
case reflect.Uint:
v, _ := strconv.ParseUint(value, 10, 64)
return uint(v)
case reflect.Uint8:
return uint8(decodeToType(reflect.Uint, value).(uint))
case reflect.Uint16:
return uint16(decodeToType(reflect.Uint, value).(uint))
case reflect.Uint32:
return uint32(decodeToType(reflect.Uint, value).(uint))
case reflect.Uint64:
return uint64(decodeToType(reflect.Uint, value).(uint))
case reflect.Float64:
v, _ := strconv.ParseFloat(value, 64)
return v
case reflect.Float32:
return float32(decodeToType(reflect.Float64, value).(float64))
}
return nil
}
func unmarshalToType(typ reflect.Type, value string) (val interface{}, err error) {
// If we get a pointer in, we'll return a pointer out
if typ.Kind() == reflect.Ptr {
typ = typ.Elem()
}
val = reflect.New(typ).Interface()
defer func() {
if err == nil && typ.Kind() != reflect.Ptr {
val = reflect.Indirect(reflect.ValueOf(val)).Interface()
}
}()
// Try Unmarshalers
if um, ok := val.(encoding.TextUnmarshaler); ok {
if err = um.UnmarshalText([]byte(value)); err == nil {
return val, nil
}
}
if um, ok := val.(json.Unmarshaler); ok {
if err = um.UnmarshalJSON([]byte(value)); err == nil {
return val, nil
}
}
// Try JSON
if err = json.Unmarshal([]byte(value), val); err == nil {
return val, nil
}
// Return error if we have one
if err != nil {
return nil, err
}
return val, fmt.Errorf("No way to unmarshal \"%s\" to %s", value, typ.Name())
}
// FromStringStringMap decodes input into output with the same type as base. Only fields tagged by tagName get decoded. Optional argument properties specifies fields to decode.
func FromStringStringMap(tagName string, base interface{}, input map[string]string) (output interface{}, err error) {
baseType := reflect.TypeOf(base)
valType := baseType
if baseType.Kind() == reflect.Ptr {
valType = valType.Elem()
}
// If we get a pointer in, we'll return a pointer out
valPtr := reflect.New(valType)
val := valPtr.Elem()
output = valPtr.Interface()
defer func() {
if err == nil && baseType.Kind() != reflect.Ptr {
output = reflect.Indirect(reflect.ValueOf(output)).Interface()
}
}()
for i := 0; i < valType.NumField(); i++ {
field := valType.Field(i)
if field.Anonymous {
continue
}
tagField, _ := parseTag(field.Tag.Get(tagName))
if tagField == "" || tagField == "-" {
continue
}
str, ok := input[tagField]
if !ok || str == "" {
continue
}
fieldType := field.Type
fieldKind := field.Type.Kind()
isPointerField := fieldKind == reflect.Ptr
if isPointerField {
if str == "null" {
continue
}
fieldType = fieldType.Elem()
fieldKind = fieldType.Kind()
}
var fieldVal interface{}
switch fieldKind {
case reflect.Struct, reflect.Array, reflect.Interface, reflect.Slice, reflect.Map:
fieldVal, err = unmarshalToType(fieldType, str)
if err != nil {
return nil, err
}
default:
fieldVal = decodeToType(fieldKind, str)
}
if isPointerField {
fieldValPtr := reflect.New(fieldType)
fieldValPtr.Elem().Set(reflect.ValueOf(fieldVal))
val.Field(i).Set(fieldValPtr)
} else {
val.Field(i).Set(reflect.ValueOf(fieldVal))
}
}
return output, nil
} | vendor/github.com/TheThingsNetwork/go-utils/encoding/decode.go | 0.586878 | 0.466785 | decode.go | starcoder |
package nifi
import (
"encoding/json"
)
// ComponentDifferenceDTO struct for ComponentDifferenceDTO
type ComponentDifferenceDTO struct {
// The type of component
ComponentType *string `json:"componentType,omitempty"`
// The ID of the component
ComponentId *string `json:"componentId,omitempty"`
// The name of the component
ComponentName *string `json:"componentName,omitempty"`
// The ID of the Process Group that the component belongs to
ProcessGroupId *string `json:"processGroupId,omitempty"`
// The differences in the component between the two flows
Differences *[]DifferenceDTO `json:"differences,omitempty"`
}
// NewComponentDifferenceDTO instantiates a new ComponentDifferenceDTO object
// This constructor will assign default values to properties that have it defined,
// and makes sure properties required by API are set, but the set of arguments
// will change when the set of required properties is changed
func NewComponentDifferenceDTO() *ComponentDifferenceDTO {
this := ComponentDifferenceDTO{}
return &this
}
// NewComponentDifferenceDTOWithDefaults instantiates a new ComponentDifferenceDTO object
// This constructor will only assign default values to properties that have it defined,
// but it doesn't guarantee that properties required by API are set
func NewComponentDifferenceDTOWithDefaults() *ComponentDifferenceDTO {
this := ComponentDifferenceDTO{}
return &this
}
// GetComponentType returns the ComponentType field value if set, zero value otherwise.
func (o *ComponentDifferenceDTO) GetComponentType() string {
if o == nil || o.ComponentType == nil {
var ret string
return ret
}
return *o.ComponentType
}
// GetComponentTypeOk returns a tuple with the ComponentType field value if set, nil otherwise
// and a boolean to check if the value has been set.
func (o *ComponentDifferenceDTO) GetComponentTypeOk() (*string, bool) {
if o == nil || o.ComponentType == nil {
return nil, false
}
return o.ComponentType, true
}
// HasComponentType returns a boolean if a field has been set.
func (o *ComponentDifferenceDTO) HasComponentType() bool {
if o != nil && o.ComponentType != nil {
return true
}
return false
}
// SetComponentType gets a reference to the given string and assigns it to the ComponentType field.
func (o *ComponentDifferenceDTO) SetComponentType(v string) {
o.ComponentType = &v
}
// GetComponentId returns the ComponentId field value if set, zero value otherwise.
func (o *ComponentDifferenceDTO) GetComponentId() string {
if o == nil || o.ComponentId == nil {
var ret string
return ret
}
return *o.ComponentId
}
// GetComponentIdOk returns a tuple with the ComponentId field value if set, nil otherwise
// and a boolean to check if the value has been set.
func (o *ComponentDifferenceDTO) GetComponentIdOk() (*string, bool) {
if o == nil || o.ComponentId == nil {
return nil, false
}
return o.ComponentId, true
}
// HasComponentId returns a boolean if a field has been set.
func (o *ComponentDifferenceDTO) HasComponentId() bool {
if o != nil && o.ComponentId != nil {
return true
}
return false
}
// SetComponentId gets a reference to the given string and assigns it to the ComponentId field.
func (o *ComponentDifferenceDTO) SetComponentId(v string) {
o.ComponentId = &v
}
// GetComponentName returns the ComponentName field value if set, zero value otherwise.
func (o *ComponentDifferenceDTO) GetComponentName() string {
if o == nil || o.ComponentName == nil {
var ret string
return ret
}
return *o.ComponentName
}
// GetComponentNameOk returns a tuple with the ComponentName field value if set, nil otherwise
// and a boolean to check if the value has been set.
func (o *ComponentDifferenceDTO) GetComponentNameOk() (*string, bool) {
if o == nil || o.ComponentName == nil {
return nil, false
}
return o.ComponentName, true
}
// HasComponentName returns a boolean if a field has been set.
func (o *ComponentDifferenceDTO) HasComponentName() bool {
if o != nil && o.ComponentName != nil {
return true
}
return false
}
// SetComponentName gets a reference to the given string and assigns it to the ComponentName field.
func (o *ComponentDifferenceDTO) SetComponentName(v string) {
o.ComponentName = &v
}
// GetProcessGroupId returns the ProcessGroupId field value if set, zero value otherwise.
func (o *ComponentDifferenceDTO) GetProcessGroupId() string {
if o == nil || o.ProcessGroupId == nil {
var ret string
return ret
}
return *o.ProcessGroupId
}
// GetProcessGroupIdOk returns a tuple with the ProcessGroupId field value if set, nil otherwise
// and a boolean to check if the value has been set.
func (o *ComponentDifferenceDTO) GetProcessGroupIdOk() (*string, bool) {
if o == nil || o.ProcessGroupId == nil {
return nil, false
}
return o.ProcessGroupId, true
}
// HasProcessGroupId returns a boolean if a field has been set.
func (o *ComponentDifferenceDTO) HasProcessGroupId() bool {
if o != nil && o.ProcessGroupId != nil {
return true
}
return false
}
// SetProcessGroupId gets a reference to the given string and assigns it to the ProcessGroupId field.
func (o *ComponentDifferenceDTO) SetProcessGroupId(v string) {
o.ProcessGroupId = &v
}
// GetDifferences returns the Differences field value if set, zero value otherwise.
func (o *ComponentDifferenceDTO) GetDifferences() []DifferenceDTO {
if o == nil || o.Differences == nil {
var ret []DifferenceDTO
return ret
}
return *o.Differences
}
// GetDifferencesOk returns a tuple with the Differences field value if set, nil otherwise
// and a boolean to check if the value has been set.
func (o *ComponentDifferenceDTO) GetDifferencesOk() (*[]DifferenceDTO, bool) {
if o == nil || o.Differences == nil {
return nil, false
}
return o.Differences, true
}
// HasDifferences returns a boolean if a field has been set.
func (o *ComponentDifferenceDTO) HasDifferences() bool {
if o != nil && o.Differences != nil {
return true
}
return false
}
// SetDifferences gets a reference to the given []DifferenceDTO and assigns it to the Differences field.
func (o *ComponentDifferenceDTO) SetDifferences(v []DifferenceDTO) {
o.Differences = &v
}
func (o ComponentDifferenceDTO) MarshalJSON() ([]byte, error) {
toSerialize := map[string]interface{}{}
if o.ComponentType != nil {
toSerialize["componentType"] = o.ComponentType
}
if o.ComponentId != nil {
toSerialize["componentId"] = o.ComponentId
}
if o.ComponentName != nil {
toSerialize["componentName"] = o.ComponentName
}
if o.ProcessGroupId != nil {
toSerialize["processGroupId"] = o.ProcessGroupId
}
if o.Differences != nil {
toSerialize["differences"] = o.Differences
}
return json.Marshal(toSerialize)
}
type NullableComponentDifferenceDTO struct {
value *ComponentDifferenceDTO
isSet bool
}
func (v NullableComponentDifferenceDTO) Get() *ComponentDifferenceDTO {
return v.value
}
func (v *NullableComponentDifferenceDTO) Set(val *ComponentDifferenceDTO) {
v.value = val
v.isSet = true
}
func (v NullableComponentDifferenceDTO) IsSet() bool {
return v.isSet
}
func (v *NullableComponentDifferenceDTO) Unset() {
v.value = nil
v.isSet = false
}
func NewNullableComponentDifferenceDTO(val *ComponentDifferenceDTO) *NullableComponentDifferenceDTO {
return &NullableComponentDifferenceDTO{value: val, isSet: true}
}
func (v NullableComponentDifferenceDTO) MarshalJSON() ([]byte, error) {
return json.Marshal(v.value)
}
func (v *NullableComponentDifferenceDTO) UnmarshalJSON(src []byte) error {
v.isSet = true
return json.Unmarshal(src, &v.value)
} | model_component_difference_dto.go | 0.732974 | 0.40116 | model_component_difference_dto.go | starcoder |
package bst
import (
"errors"
"fmt"
"../queue"
)
// 在我们的实现中，二叉搜索树是不包含重复元素的
// 没想到，用了递归，竟如此简单
type BST struct {
root *Node
size int
}
func New() *BST {
return &BST{root: nil, size: 0,}
}
func (this *BST) GetSize() int {
return this.size
}
func (this *BST) IsEmpty() bool {
return this.size == 0
}
func (this *BST) Add(value int) {
this.root = this.add(this.root, value)
}
func (this *BST) add(root *Node, value int) *Node {
if root == nil {
node := &Node{value: value,}
this.size++
return node
}
if value < root.value {
root.left = this.add(root.left, value)
}
if value > root.value {
root.right = this.add(root.right, value)
}
return root
}
func (this *BST) Contains(value int) bool {
return this.contains(this.root, value)
}
func (this *BST) contains(root *Node, value int) bool {
if root == nil {
return false
}
if root.value == value {
return true
}
if value < root.value {
return this.contains(root.left, value)
}
return this.contains(root.right, value)
}
func (t *BST) PreOrder() {
t.preOrder(t.root)
}
func (t *BST) preOrder(node *Node) {
if node == nil {
return
}
// 我们这里简化一下，遍历操作只打印一下节点值
// 理论上来说，遍历方法应该接收一个函数作为参数
// 让这个函数去具体执行遍历时要对节点进行的操作
// 但是在 Go 中好像没有函数指针，那我们无法确定函数的签名是怎样的
fmt.Printf("%v ", node.value)
t.preOrder(node.left)
t.preOrder(node.right)
}
func (t *BST) InOrder() {
t.inOrder(t.root)
}
func (t *BST) inOrder(node *Node) {
if node == nil {
return
}
t.inOrder(node.left)
fmt.Printf("%v ", node.value)
t.inOrder(node.right)
}
func (t *BST) PostOrder() {
t.postOrder(t.root)
}
func (t *BST) postOrder(node *Node) {
if node == nil {
return
}
t.postOrder(node.left)
t.postOrder(node.right)
fmt.Printf("%v ", node.value)
}
func (t *BST) LevelOrder() {
queue := queue.New()
queue.Enqueue(t.root)
for ; !queue.IsEmpty(); {
node, _ := queue.Dequeue()
fmt.Println(node)
// 这里由于不支持泛型，只能使用类型断言来实现
switch node := node.(type) {
case *Node:
if node.left != nil {
queue.Enqueue(node.left)
}
if node.right != nil {
queue.Enqueue(node.right)
}
}
}
}
// 返回树中的最大值，需要注意与下面内部方法返回值的区别
// 这个方法会返回的最大值节点中的值，而下面的是返回最大值的那个节点
func (this *BST) Maximum() (int, error) {
if this.root == nil {
return 0, errors.New("BST is Empty")
}
maxNode := this.maximum(this.root)
return maxNode.value, nil
}
// 返回最大值所在节点
func (this *BST) maximum(root *Node) *Node {
if root.right != nil {
return this.maximum(root.right)
}
return root
}
// 返回树中的最小值，需要注意与下面内部方法返回值的区别
// 这个方法会返回的最小值节点中的值，而下面的是返回最小值的那个节点
func (this *BST) Minimum() (int, error) {
if this.root == nil {
return 0, errors.New("BST is Empty")
}
minNode := this.minimum(this.root)
return minNode.value, nil
}
// 返回最小值所在节点
func (this *BST) minimum(root *Node) *Node {
if root.left != nil {
return this.minimum(root.left)
}
return root
}
func (this *BST) RemoveMax() (int, error) {
if this.root == nil {
return 0, errors.New("BST is empty")
}
value, _ := this.Maximum()
this.root = this.removeMax(this.root)
return value, nil
}
func (this *BST) removeMax(root *Node) *Node {
if root.right != nil {
root.right = this.removeMax(root.right)
return root
}
this.size--
return root.left
}
func (this *BST) RemoveMin() (int, error) {
if this.root == nil {
return 0, errors.New("BST is empty")
}
value, _ := this.Minimum()
this.root = this.removeMin(this.root)
return value, nil
}
func (this *BST) removeMin(root *Node) *Node {
if root.left != nil {
root.left = this.removeMin(root.left)
return root
}
this.size--
return root.right
}
func (this *BST) Remove(value int) error {
if this.Contains(value) == false {
return errors.New("Value wasn't in BST")
}
this.root = this.remove(this.root, value)
return nil
}
func (this *BST) remove(root *Node, value int) *Node {
if root == nil {
return nil
}
if value < root.value {
root.left = this.remove(root.left, value)
return root
}
if value > root.value {
root.right = this.remove(root.right, value)
return root
}
if root.left == nil {
right := root.right
root.right = nil
this.size--
return right
}
if root.right == nil {
left := root.left
root.left = nil
this.size--
return left
}
successor := this.minimum(root.right)
successor.left = root.left
successor.right = this.removeMin(root.right)
root.left = nil
root.right = nil
return successor
}
func (t *BST) String() string {
return "not done"
} | go/bst/bst.go | 0.523177 | 0.496155 | bst.go | starcoder |
package convolve
import (
"errors"
)
// Slice32 convolves given kernel with given source slice, putting results in
// destination, which is ensured to be the same size as the source slice,
// using existing capacity if available, and otherwise making a new slice.
// The kernel should be normalized, and odd-sized do it is symmetric about 0.
// Returns an error if sizes are not valid.
// No parallelization is used -- see Slice32Parallel for very large slices.
// Edges are handled separately with renormalized kernels -- they can be
// clipped from dest by excluding the kernel half-width from each end.
func Slice32(dest *[]float32, src []float32, kern []float32) error {
sz := len(src)
ksz := len(kern)
if ksz == 0 || sz == 0 {
return errors.New("convolve.Slice32: kernel or source are empty")
}
if ksz%2 == 0 {
return errors.New("convolve.Slice32: kernel is not odd sized")
}
if sz < ksz {
return errors.New("convolve.Slice32: source must be > kernel in size")
}
khalf := (ksz - 1) / 2
if len(*dest) != sz {
if cap(*dest) >= sz {
*dest = (*dest)[:sz]
} else {
*dest = make([]float32, sz)
}
}
for i := khalf; i < sz-khalf; i++ {
var sum float32
for j := 0; j < ksz; j++ {
sum += src[(i-khalf)+j] * kern[j]
}
(*dest)[i] = sum
}
for i := 0; i < khalf; i++ {
var sum, ksum float32
for j := 0; j <= khalf+i; j++ {
ki := (j + khalf) - i // 0: 1+kh, 1: etc
si := i + (ki - khalf)
// fmt.Printf("i: %d j: %d ki: %d si: %d\n", i, j, ki, si)
sum += src[si] * kern[ki]
ksum += kern[ki]
}
(*dest)[i] = sum / ksum
}
for i := sz - khalf; i < sz; i++ {
var sum, ksum float32
ei := sz - i - 1
for j := 0; j <= khalf+ei; j++ {
ki := ((ksz - 1) - (j + khalf)) + ei
si := i + (ki - khalf)
// fmt.Printf("i: %d j: %d ki: %d si: %d ei: %d\n", i, j, ki, si, ei)
sum += src[si] * kern[ki]
ksum += kern[ki]
}
(*dest)[i] = sum / ksum
}
return nil
}
// Slice64 convolves given kernel with given source slice, putting results in
// destination, which is ensured to be the same size as the source slice,
// using existing capacity if available, and otherwise making a new slice.
// The kernel should be normalized, and odd-sized do it is symmetric about 0.
// Returns an error if sizes are not valid.
// No parallelization is used -- see Slice64Parallel for very large slices.
// Edges are handled separately with renormalized kernels -- they can be
// clipped from dest by excluding the kernel half-width from each end.
func Slice64(dest *[]float64, src []float64, kern []float64) error {
sz := len(src)
ksz := len(kern)
if ksz == 0 || sz == 0 {
return errors.New("convolve.Slice64: kernel or source are empty")
}
if ksz%2 == 0 {
return errors.New("convolve.Slice64: kernel is not odd sized")
}
if sz < ksz {
return errors.New("convolve.Slice64: source must be > kernel in size")
}
khalf := (ksz - 1) / 2
if len(*dest) != sz {
if cap(*dest) >= sz {
*dest = (*dest)[:sz]
} else {
*dest = make([]float64, sz)
}
}
for i := khalf; i < sz-khalf; i++ {
var sum float64
for j := 0; j < ksz; j++ {
sum += src[(i-khalf)+j] * kern[j]
}
(*dest)[i] = sum
}
for i := 0; i < khalf; i++ {
var sum, ksum float64
for j := 0; j <= khalf+i; j++ {
ki := (j + khalf) - i // 0: 1+kh, 1: etc
si := i + (ki - khalf)
// fmt.Printf("i: %d j: %d ki: %d si: %d\n", i, j, ki, si)
sum += src[si] * kern[ki]
ksum += kern[ki]
}
(*dest)[i] = sum / ksum
}
for i := sz - khalf; i < sz; i++ {
var sum, ksum float64
ei := sz - i - 1
for j := 0; j <= khalf+ei; j++ {
ki := ((ksz - 1) - (j + khalf)) + ei
si := i + (ki - khalf)
// fmt.Printf("i: %d j: %d ki: %d si: %d ei: %d\n", i, j, ki, si, ei)
sum += src[si] * kern[ki]
ksum += kern[ki]
}
(*dest)[i] = sum / ksum
}
return nil
} | convolve/convolve.go | 0.73659 | 0.411347 | convolve.go | starcoder |
package awsutil
import (
"io/ioutil"
"net"
"os"
"strings"
"time"
)
// ComputeType is an enum for different compute types
type ComputeType int
const (
// ComputeUnknown is when the compute type could not be identified
ComputeUnknown ComputeType = iota
// ComputeEC2 is running in an EC2 instance
ComputeEC2
// ComputeDocker is running in a docker container (and is not ECS, EKS, or kubernetes)
ComputeDocker
// ComputeKubernetes is running in a kubernetes pod (and is not EKS)
ComputeKubernetes
// ComputeECS is running in an ECS task
ComputeECS
// ComputeEKS is running in an EKS pod
ComputeEKS
// ComputeLambda is running in a Lambda function
ComputeLambda
)
// String is the string representation of the ComputeType
func (ct ComputeType) String() string {
return [...]string{"unknown", "ec2", "docker", "kubernetes", "ecs", "eks", "lambda"}[ct]
}
// DetectOutput is the output struct for the Detect() function
type DetectOutput struct {
Type ComputeType
}
// String is the string representation of the ComputeType
func (do DetectOutput) String() string {
return do.Type.String()
}
// IsEC2 returns whether this is running in an EC2 instance
func (do DetectOutput) IsEC2() bool {
return do.Type == ComputeEC2
}
// IsDocker returns whether this is running in a docker container (and is not ECS, EKS, or kubernetes)
func (do DetectOutput) IsDocker() bool {
return do.Type == ComputeDocker
}
// IsKubernetes returns whether this is running in a kubernetes pod (and is not EKS)
func (do DetectOutput) IsKubernetes() bool {
return do.Type == ComputeKubernetes
}
// IsECS returns whether this is running in an ECS task
func (do DetectOutput) IsECS() bool {
return do.Type == ComputeECS
}
// IsEKS returns whether this is running in an EKS pod
func (do DetectOutput) IsEKS() bool {
return do.Type == ComputeEKS
}
// IsLambda returns whether this is running in a Lambda function
func (do DetectOutput) IsLambda() bool {
return do.Type == ComputeLambda
}
// IsEC2 returns whether this is running in an EC2 instance
func IsEC2(do DetectOutput) bool {
return do.IsEC2()
}
// IsDocker returns whether this is running in a docker container (and is not ECS, EKS, or kubernetes)
func IsDocker(do DetectOutput) bool {
return do.IsDocker()
}
// IsKubernetes returns whether this is running in a kubernetes pod (and is not EKS)
func IsKubernetes(do DetectOutput) bool {
return do.IsKubernetes()
}
// IsECS returns whether this is running in an ECS task
func IsECS(do DetectOutput) bool {
return do.IsECS()
}
// IsEKS returns whether this is running in an EKS pod
func IsEKS(do DetectOutput) bool {
return do.IsEKS()
}
// IsLambda returns whether this is running in a Lambda function
func IsLambda(do DetectOutput) bool {
return do.IsLambda()
}
// Detect attempts to determine the compute type of the currently running code.
func Detect() DetectOutput {
do := DetectOutput{}
switch {
case checkLambda():
do.Type = ComputeLambda
case checkECS():
do.Type = ComputeECS
// case checkEKS():
// do.Type = ComputeEKS
case checkKubernetes():
do.Type = ComputeKubernetes
case checkDocker():
do.Type = ComputeDocker
case checkEC2():
do.Type = ComputeEC2
default:
do.Type = ComputeUnknown
}
return do
}
// Lambda has two environment variables
func checkLambda() bool {
if _, ok := os.LookupEnv("LAMBDA_TASK_ROOT"); ok {
return true
}
return strings.HasPrefix(os.Getenv("AWS_EXECUTION_ENV"), "AWS_Lambda_")
}
func checkECS() bool {
return strings.HasPrefix(os.Getenv("AWS_EXECUTION_ENV"), "AWS_ECS_")
}
// Kubernetes sets environment variables and creates a specific folder
func checkKubernetes() bool {
// KUBERNETES_SERVICE_HOST environment variable
if _, ok := os.LookupEnv("KUBERNETES_SERVICE_HOST"); ok {
return true
}
// folder /var/run/secrets/kubernetes.io exists?
_, err := os.Stat("/var/run/secrets/kubernetes.io")
return err != nil && os.IsExist(err)
}
// Docker containers typically contain "docker" in the cgroup names
func checkDocker() bool {
cgroupBytes, err := ioutil.ReadFile("/proc/self/cgroup")
if err != nil {
return false
}
cgroup := string(cgroupBytes)
return strings.Contains(cgroup, "docker")
}
// checkEC2 inspects the IMDS endpoint (instance metadata) for a valid network connection
func checkEC2() bool {
conn, err := net.DialTimeout("tcp4", "169.254.169.254:80", 25*time.Millisecond)
defer conn.Close()
return err != nil
} | aws/awsutil/detector.go | 0.683525 | 0.40592 | detector.go | starcoder |
package codewords
var nouns = []string{
"aachen",
"aalborg",
"aalii",
"aalst",
"aalto",
"aardvark",
"aardwolf",
"aare",
"aarhus",
"aaron",
"aarp",
"aave",
"abaca",
"abacus",
"abadan",
"abalone",
"abamp",
"abampere",
"abandon",
"abandonment",
"abarticulation",
"abasement",
"abashment",
"abasia",
"abatement",
"abatis",
"abator",
"abattis",
"abattoir",
"abaya",
"abbacy",
"abbe",
"abbess",
"abbey",
"abbot",
"abbreviation",
"abbreviator",
"abcoulomb",
"abcs",
"abdias",
"abdication",
"abdicator",
"abdomen",
"abdominal",
"abdominoplasty",
"abdominousness",
"abducens",
"abducent",
"abduction",
"abductor",
"abecedarian",
"abecedarius",
"abel",
"abelard",
"abele",
"abelia",
"abelmoschus",
"abelmosk",
"abenaki",
"aberdare",
"aberdeen",
"aberrance",
"aberrancy",
"aberrant",
"aberration",
"abetment",
"abettal",
"abetter",
"abettor",
"abeyance",
"abfarad",
"abhenry",
"abhorrence",
"abhorrer",
"abidance",
"abidjan",
"abience",
"abies",
"abila",
"abilene",
"ability",
"abiogenesis",
"abiogenist",
"abiotrophy",
"abjection",
"abjuration",
"abjurer",
"abkhas",
"abkhasian",
"abkhaz",
"abkhazia",
"abkhazian",
"ablactation",
"ablation",
"ablative",
"ablaut",
"ableism",
"ablepharia",
"ablism",
"abls",
"ablution",
"abnaki",
"abnegation",
"abnegator",
"abnormalcy",
"abnormality",
"abocclusion",
"abode",
"abohm",
"abolishment",
"abolition",
"abolitionism",
"abolitionist",
"abomasum",
"abomination",
"abominator",
"abor",
"aboriginal",
"aborigine",
"abort",
"aborticide",
"abortifacient",
"abortion",
"abortionist",
"abortus",
"aboulia",
"above",
"abracadabra",
"abrachia",
"abradant",
"abrader",
"abraham",
"abramis",
"abrasion",
"abrasive",
"abrasiveness",
"abreaction",
"abridgement",
"abridger",
"abridgment",
"abrocoma",
"abrocome",
"abrogation",
"abrogator",
"abronia",
"abruption",
"abruptness",
"abruzzi",
"abscess",
"abscissa",
"abscission",
"absconder",
"abscondment",
"abseil",
"abseiler",
"absence",
"absentee",
"absenteeism",
"absinth",
"absinthe",
"absolute",
"absoluteness",
"absolution",
"absolutism",
"absolutist",
"absolver",
"absorbance",
"absorbate",
"absorbency",
"absorbent",
"absorber",
"absorptance",
"absorption",
"absorptivity",
"abstainer",
"abstemiousness",
"abstention",
"abstinence",
"abstinent",
"abstract",
"abstractedness",
"abstracter",
"abstraction",
"abstractionism",
"abstractionist",
"abstractness",
"abstractor",
"abstruseness",
"abstrusity",
"absurd",
"absurdity",
"absurdness",
"abudefduf",
"abuja",
"abukir",
"abulia",
"abundance",
"abuse",
"abuser",
"abutilon",
"abutment",
"abutter",
"abvolt",
"abwatt",
"abydos",
"abyla",
"abysm",
"abyss",
"abyssinia",
"abyssinian",
"acacia",
"academe",
"academia",
"academic",
"academician",
"academicianship",
"academicism",
"academism",
"academy",
"acadia",
"acadian",
"acalypha",
"acantha",
"acanthaceae",
"acanthion",
"acanthisitta",
"acanthisittidae",
"acanthocephala",
"acanthocephalan",
"acanthocereus",
"acanthocybium",
"acanthocyte",
"acanthocytosis",
"acantholysis",
"acanthoma",
"acanthophis",
"acanthopterygii",
"acanthoscelides",
"acanthosis",
"acanthuridae",
"acanthurus",
"acanthus",
"acapnia",
"acapulco",
"acaracide",
"acardia",
"acariasis",
"acaricide",
"acarid",
"acaridae",
"acaridiasis",
"acarina",
"acarine",
"acariosis",
"acarophobia",
"acarus",
"acaryote",
"acatalectic",
"acataphasia",
"acathexia",
"acathexis",
"accelerando",
"acceleration",
"accelerator",
"accelerometer",
"accent",
"accenting",
"accentor",
"accentuation",
"acceptability",
"acceptableness",
"acceptance",
"acceptation",
"acceptor",
"access",
"accessary",
"accessibility",
"accession",
"accessory",
"accho",
"acciaccatura",
"accidence",
"accident",
"accidental",
"accipiter",
"accipitridae",
"accipitriformes",
"acclaim",
"acclamation",
"acclimation",
"acclimatisation",
"acclimatization",
"acclivity",
"accolade",
"accommodation",
"accommodator",
"accompaniment",
"accompanist",
"accompanyist",
"accomplice",
"accomplishment",
"accord",
"accordance",
"accordion",
"accordionist",
"accouchement",
"accoucheur",
"accoucheuse",
"account",
"accountability",
"accountancy",
"accountant",
"accountantship",
"accounting",
"accouterment",
"accoutrement",
"accra",
"accreditation",
"accretion",
"accroides",
"accrual",
"accruement",
"acculturation",
"accumulation",
"accumulator",
"accuracy",
"accusal",
"accusation",
"accusative",
"accused",
"accuser",
"acebutolol",
"acedia",
"acephalia",
"acephalism",
"acephaly",
"acer",
"aceraceae",
"acerbity",
"acerola",
"acervulus",
"acetabulum",
"acetal",
"acetaldehyde",
"acetaldol",
"acetamide",
"acetaminophen",
"acetanilid",
"acetanilide",
"acetate",
"acetin",
"acetone",
"acetonemia",
"acetonuria",
"acetophenetidin",
"acetphenetidin",
"acetum",
"acetyl",
"acetylation",
"acetylcholine",
"acetylene",
"achaea",
"achaean",
"achaian",
"ache",
"achene",
"acheron",
"acherontia",
"acheson",
"acheta",
"achievability",
"achievement",
"achiever",
"achillea",
"achilles",
"achimenes",
"aching",
"achira",
"achlorhydria",
"achoerodus",
"acholia",
"achomawi",
"achondrite",
"achondroplasia",
"achondroplasty",
"achras",
"achromasia",
"achromaticity",
"achromatin",
"achromatism",
"achromia",
"achromycin",
"achylia",
"acicula",
"acid",
"acidemia",
"acidification",
"acidimetry",
"acidity",
"acidophil",
"acidophile",
"acidophilus",
"acidosis",
"acidulousness",
"acinonyx",
"acinos",
"acinus",
"acipenser",
"acipenseridae",
"ackee",
"acknowledgement",
"acknowledgment",
"aclant",
"acme",
"acne",
"acnidosporidia",
"acocanthera",
"acokanthera",
"acolyte",
"aconcagua",
"aconite",
"aconitum",
"acoraceae",
"acorea",
"acores",
"acorn",
"acorus",
"acousma",
"acoustic",
"acoustician",
"acousticophobia",
"acoustics",
"acquaintance",
"acquiescence",
"acquirement",
"acquirer",
"acquiring",
"acquisition",
"acquisitiveness",
"acquittal",
"acquittance",
"acragas",
"acrasiomycetes",
"acre",
"acreage",
"acres",
"acridid",
"acrididae",
"acridity",
"acridness",
"acridotheres",
"acrilan",
"acrimony",
"acris",
"acroanaesthesia",
"acroanesthesia",
"acrobat",
"acrobates",
"acrobatics",
"acrocarp",
"acrocarpus",
"acrocephalus",
"acrocephaly",
"acroclinium",
"acrocomia",
"acrocyanosis",
"acrodont",
"acrogen",
"acrolein",
"acromegalia",
"acromegaly",
"acromicria",
"acromikria",
"acromion",
"acromphalus",
"acromyotonia",
"acronym",
"acrophobia",
"acrophony",
"acropolis",
"acropora",
"acrosome",
"acrostic",
"acrostichum",
"acrylamide",
"acrylate",
"acrylic",
"acrylonitrile",
"actaea",
"acth",
"actias",
"actifed",
"actin",
"actinaria",
"acting",
"actinia",
"actinian",
"actiniaria",
"actiniarian",
"actinide",
"actinidia",
"actinidiaceae",
"actiniopteris",
"actinism",
"actinium",
"actinoid",
"actinolite",
"actinomeris",
"actinometer",
"actinometry",
"actinomyces",
"actinomycetales",
"actinomycete",
"actinomycin",
"actinomycosis",
"actinomyxidia",
"actinomyxidian",
"actinon",
"actinopod",
"actinopoda",
"actinotherapy",
"actinozoa",
"actinozoan",
"action",
"actitis",
"actium",
"activase",
"activating",
"activation",
"activator",
"active",
"activeness",
"activewear",
"activism",
"activist",
"activity",
"actomyosin",
"actor",
"actress",
"acts",
"actualisation",
"actuality",
"actualization",
"actuary",
"actuation",
"actuator",
"acuity",
"acular",
"aculea",
"aculeus",
"acumen",
"acupressure",
"acupuncture",
"acute",
"acuteness",
"acyclovir",
"acyl",
"acylation",
"acylglycerol",
"adactylia",
"adactylism",
"adactyly",
"adad",
"adage",
"adagio",
"adalia",
"adam",
"adamance",
"adamant",
"adams",
"adana",
"adansonia",
"adapa",
"adapid",
"adapin",
"adaptability",
"adaptation",
"adapter",
"adaption",
"adaptor",
"adar",
"addax",
"addend",
"addendum",
"adder",
"addict",
"addiction",
"addition",
"additive",
"addlehead",
"address",
"addressee",
"addressograph",
"adducer",
"adducing",
"adduct",
"adduction",
"adductor",
"adelaide",
"adelges",
"adelgid",
"adelgidae",
"adelie",
"aden",
"adenanthera",
"adenauer",
"adenine",
"adenitis",
"adenium",
"adenocarcinoma",
"adenohypophysis",
"adenoid",
"adenoidectomy",
"adenoma",
"adenomegaly",
"adenomyosarcoma",
"adenomyosis",
"adenopathy",
"adenosine",
"adenosis",
"adenota",
"adenovirus",
"adept",
"adeptness",
"adequacy",
"adequateness",
"adermin",
"adesite",
"adhd",
"adherence",
"adherent",
"adhesion",
"adhesive",
"adhesiveness",
"adhocracy",
"adiantaceae",
"adiantum",
"adience",
"adieu",
"adige",
"adios",
"adiposeness",
"adiposis",
"adiposity",
"adirondacks",
"adit",
"aditi",
"aditya",
"adjacency",
"adjective",
"adjournment",
"adjudication",
"adjudicator",
"adjunct",
"adjunction",
"adjuration",
"adjuster",
"adjustment",
"adjustor",
"adjutant",
"adjuvant",
"adlumia",
"adman",
"admass",
"administration",
"administrator",
"administrivia",
"admirability",
"admirableness",
"admiral",
"admiralty",
"admiration",
"admirer",
"admissibility",
"admission",
"admittance",
"admixture",
"admonisher",
"admonishment",
"admonition",
"adnexa",
"adnoun",
"adobe",
"adobo",
"adolescence",
"adolescent",
"adonic",
"adonis",
"adoptee",
"adopter",
"adoption",
"adorability",
"adorableness",
"adoration",
"adorer",
"adornment",
"adoxography",
"adps",
"adrenal",
"adrenalectomy",
"adrenalin",
"adrenaline",
"adrenarche",
"adrenergic",
"adrenosterone",
"adrian",
"adrianople",
"adrianopolis",
"adriatic",
"adroitness",
"adsorbate",
"adsorbent",
"adsorption",
"adulation",
"adulator",
"adult",
"adulterant",
"adulteration",
"adulterator",
"adulterer",
"adulteress",
"adultery",
"adulthood",
"adumbration",
"advance",
"advancement",
"advancer",
"advantage",
"advection",
"advent",
"adventism",
"adventist",
"adventitia",
"adventure",
"adventurer",
"adventuress",
"adventurism",
"adventurousness",
"adverb",
"adverbial",
"adversary",
"adversity",
"advert",
"advertence",
"advertency",
"advertisement",
"advertiser",
"advertising",
"advertizement",
"advertizer",
"advertizing",
"advertorial",
"advice",
"advil",
"advisability",
"advisee",
"advisement",
"adviser",
"advisor",
"advisory",
"advocacy",
"advocate",
"advocator",
"advowson",
"adynamia",
"adze",
"adzhar",
"adzharia",
"aeciospore",
"aecium",
"aedes",
"aegates",
"aegean",
"aegiceras",
"aegilops",
"aegina",
"aegir",
"aegis",
"aegisthus",
"aegospotami",
"aegospotamos",
"aegypiidae",
"aegypius",
"aegyptopithecus",
"aeneas",
"aeneid",
"aengus",
"aeolia",
"aeolian",
"aeolic",
"aeolis",
"aeolus",
"aeon",
"aeonium",
"aepyceros",
"aepyornidae",
"aepyorniformes",
"aepyornis",
"aeration",
"aerator",
"aerial",
"aerialist",
"aerides",
"aerie",
"aerobacter",
"aerobatics",
"aerobe",
"aerobics",
"aerobiosis",
"aerodontalgia",
"aerodrome",
"aerodynamics",
"aeroembolism",
"aerofoil",
"aerogenerator",
"aerogram",
"aerogramme",
"aerolite",
"aerology",
"aeromechanics",
"aeromedicine",
"aeronaut",
"aeronautics",
"aerophagia",
"aerophilately",
"aerophile",
"aerophyte",
"aeroplane",
"aerosol",
"aerospace",
"aertex",
"aery",
"aeschylus",
"aeschynanthus",
"aesculapius",
"aesculus",
"aesir",
"aesop",
"aesthesia",
"aesthesis",
"aesthete",
"aesthetic",
"aesthetician",
"aesthetics",
"aestivation",
"aether",
"aethionema",
"aethusa",
"aetiologist",
"aetiology",
"aetobatus",
"affability",
"affableness",
"affair",
"affaire",
"affairs",
"affect",
"affectation",
"affectedness",
"affection",
"affenpinscher",
"afferent",
"affiant",
"affidavit",
"affiliate",
"affiliation",
"affine",
"affinity",
"affirmation",
"affirmative",
"affirmativeness",
"affirmed",
"affirmer",
"affix",
"affixation",
"afflatus",
"affliction",
"affluence",
"affluent",
"afforestation",
"affray",
"affricate",
"affrication",
"affricative",
"affright",
"affront",
"affusion",
"afghan",
"afghani",
"afghanistan",
"afghanistani",
"afibrinogenemia",
"aficionado",
"afisr",
"aflatoxin",
"aflaxen",
"aframomum",
"afrasian",
"africa",
"african",
"africander",
"afrikaans",
"afrikander",
"afrikaner",
"afrl",
"afro",
"afroasiatic",
"afrocarpus",
"afropavo",
"afspc",
"afterbirth",
"afterburner",
"aftercare",
"afterdamp",
"afterdeck",
"aftereffect",
"afterglow",
"afterimage",
"afterlife",
"aftermath",
"afternoon",
"afterpains",
"afterpiece",
"afters",
"aftersensation",
"aftershaft",
"aftershock",
"aftertaste",
"afterthought",
"afterworld",
"agal",
"agalactia",
"agalactosis",
"agalinis",
"agama",
"agamemnon",
"agamete",
"agamid",
"agamidae",
"agamogenesis",
"agapanthus",
"agape",
"agapornis",
"agar",
"agaric",
"agaricaceae",
"agaricales",
"agaricus",
"agassiz",
"agastache",
"agate",
"agateware",
"agathis",
"agavaceae",
"agave",
"agdestis",
"agdistis",
"aged",
"agedness",
"agee",
"ageing",
"ageism",
"agelaius",
"agelessness",
"agency",
"agenda",
"agendum",
"agene",
"agenesia",
"agenesis",
"agent",
"agerasia",
"ageratina",
"ageratum",
"aggeus",
"agglomerate",
"agglomeration",
"agglomerator",
"agglutination",
"agglutinin",
"agglutinogen",
"aggrandisement",
"aggrandizement",
"aggravation",
"aggravator",
"aggregate",
"aggregation",
"aggregator",
"aggression",
"aggressiveness",
"aggressor",
"aggro",
"agha",
"aghan",
"agility",
"agincourt",
"aging",
"agio",
"agiotage",
"agism",
"agitation",
"agitator",
"agitprop",
"agkistrodon",
"aglaia",
"aglaomorpha",
"aglaonema",
"aglet",
"agnail",
"agnate",
"agnatha",
"agnathan",
"agnation",
"agni",
"agnomen",
"agnosia",
"agnostic",
"agnosticism",
"agon",
"agonidae",
"agonist",
"agonus",
"agony",
"agora",
"agoraphobia",
"agouti",
"agra",
"agranulocytosis",
"agranulosis",
"agrapha",
"agraphia",
"agreeability",
"agreeableness",
"agreement",
"agribusiness",
"agricola",
"agriculturalist",
"agriculture",
"agriculturist",
"agrigento",
"agrimonia",
"agrimony",
"agriocharis",
"agrippa",
"agrippina",
"agrobacterium",
"agrobiology",
"agrology",
"agromania",
"agronomist",
"agronomy",
"agropyron",
"agrostemma",
"agrostis",
"agrypnia",
"agua",
"aguacate",
"ague",
"agueweed",
"ahab",
"ahem",
"ahimsa",
"ahpcrc",
"ahriman",
"ahuehuete",
"ahura",
"ahvenanmaa",
"aiai",
"aide",
"aides",
"aidoneus",
"aids",
"aigina",
"aiglet",
"aigret",
"aigrette",
"aiguilette",
"aiken",
"aikido",
"ailanthus",
"aileron",
"ailey",
"ailment",
"ailurophobia",
"ailuropoda",
"ailuropodidae",
"ailurus",
"aimlessness",
"aioli",
"airbrake",
"airbrush",
"airburst",
"airbus",
"aircraft",
"aircraftman",
"aircraftsman",
"aircrew",
"aircrewman",
"airdock",
"airdrome",
"airdrop",
"aire",
"airedale",
"airfare",
"airfield",
"airflow",
"airfoil",
"airforce",
"airframe",
"airgun",
"airhead",
"airiness",
"airing",
"airlift",
"airline",
"airliner",
"airlock",
"airmail",
"airmailer",
"airman",
"airmanship",
"airplane",
"airport",
"airpost",
"airs",
"airscrew",
"airship",
"airsickness",
"airspace",
"airspeed",
"airstream",
"airstrip",
"airwave",
"airway",
"airwoman",
"airworthiness",
"aisle",
"aitchbone",
"aizoaceae",
"ajaia",
"ajax",
"ajuga",
"akaba",
"akan",
"akaryocyte",
"akaryote",
"akee",
"aken",
"akeridae",
"akha",
"akhbari",
"akhenaten",
"akhenaton",
"akinesia",
"akinesis",
"akka",
"akkadian",
"akko",
"akmola",
"akron",
"akvavit",
"alabama",
"alabaman",
"alabamian",
"alabaster",
"alacrity",
"aladdin",
"alalia",
"alamo",
"alanine",
"alar",
"alaric",
"alarm",
"alarmism",
"alarmist",
"alarum",
"alaska",
"alaskan",
"alastrim",
"alauda",
"alaudidae",
"albacore",
"albania",
"albanian",
"albany",
"albatrellus",
"albatross",
"albedo",
"albee",
"albers",
"albert",
"alberta",
"alberti",
"albigenses",
"albigensianism",
"albinism",
"albino",
"albion",
"albite",
"albizia",
"albizzia",
"alborg",
"albuca",
"albuginaceae",
"albuginea",
"albugo",
"albula",
"albulidae",
"album",
"albumen",
"albumin",
"albuminoid",
"albuminuria",
"albuquerque",
"albuterol",
"alca",
"alcaeus",
"alcahest",
"alcaic",
"alcalde",
"alcapton",
"alcaptonuria",
"alcazar",
"alcea",
"alcedinidae",
"alcedo",
"alcelaphus",
"alces",
"alchemist",
"alchemy",
"alcibiades",
"alcidae",
"alcides",
"alcohol",
"alcoholic",
"alcoholism",
"alcott",
"alcove",
"alcyonacea",
"alcyonaria",
"alcyone",
"aldactone",
"aldebaran",
"aldehyde",
"alder",
"alderfly",
"alderman",
"aldohexose",
"aldol",
"aldomet",
"aldose",
"aldosterone",
"aldosteronism",
"aldrovanda",
"alecost",
"alectis",
"alecto",
"alectoria",
"alectoris",
"alectura",
"alehoof",
"alehouse",
"alembic",
"alendronate",
"alep",
"aleph",
"alepisaurus",
"aleppo",
"alert",
"alerting",
"alertness",
"aletris",
"aleurites",
"aleurone",
"aleut",
"aleutian",
"aleutians",
"aleve",
"alewife",
"alexander",
"alexanders",
"alexandria",
"alexandrian",
"alexandrine",
"alexandrite",
"alexia",
"alexic",
"aleyrodes",
"aleyrodidae",
"alfalfa",
"alfilaria",
"alfileria",
"alfred",
"alga",
"algae",
"algarobilla",
"algarroba",
"algarrobilla",
"algebra",
"algebraist",
"alger",
"algeria",
"algerian",
"algerie",
"algeripithecus",
"algidity",
"algiers",
"algin",
"algol",
"algolagnia",
"algology",
"algometer",
"algometry",
"algonkian",
"algonkin",
"algonquian",
"algonquin",
"algophilia",
"algophobia",
"algorism",
"algorithm",
"algren",
"alhacen",
"alhambra",
"alhazen",
"alias",
"alibi",
"alidad",
"alidade",
"alien",
"alienage",
"alienation",
"alienator",
"alienee",
"alienism",
"alienist",
"alienor",
"alignment",
"alikeness",
"aliment",
"alimentation",
"alimony",
"alinement",
"aliquant",
"aliquot",
"alir",
"alisma",
"alismales",
"alismataceae",
"alismatidae",
"aliterate",
"aliveness",
"aliyah",
"alizarin",
"alizarine",
"alkahest",
"alkalemia",
"alkali",
"alkalimetry",
"alkalinity",
"alkalinuria",
"alkaliser",
"alkalizer",
"alkaloid",
"alkalosis",
"alkaluria",
"alkane",
"alkanet",
"alkapton",
"alkaptonuria",
"alkene",
"alkeran",
"alky",
"alkyd",
"alkyl",
"alkylbenzene",
"alkyne",
"allah",
"allamanda",
"allantois",
"allayer",
"allegation",
"allegement",
"alleghenies",
"allegheny",
"allegiance",
"allegoriser",
"allegorizer",
"allegory",
"allegretto",
"allegro",
"allele",
"allelomorph",
"allemande",
"allen",
"allentown",
"allergen",
"allergist",
"allergology",
"allergy",
"alleviant",
"alleviation",
"alleviator",
"alley",
"alleyway",
"allgood",
"allhallows",
"allhallowtide",
"alliaceae",
"alliance",
"alliaria",
"allice",
"allies",
"alligator",
"alligatorfish",
"alligatoridae",
"allionia",
"allioniaceae",
"allis",
"alliteration",
"alliterator",
"allium",
"allmouth",
"alloantibody",
"allocation",
"allocator",
"allocution",
"allogamy",
"allograft",
"allograph",
"allomerism",
"allometry",
"allomorph",
"allopathy",
"allopatry",
"allophone",
"allopurinol",
"allosaur",
"allosaurus",
"allotment",
"allotrope",
"allotropism",
"allotropy",
"allowance",
"alloy",
"allspice",
"allure",
"allurement",
"allusion",
"allusiveness",
"alluviation",
"alluvion",
"alluvium",
"ally",
"allyl",
"almanac",
"almandine",
"almandite",
"almaty",
"almighty",
"almond",
"almoner",
"almoravid",
"alms",
"almsgiver",
"almsgiving",
"alnico",
"alnus",
"alocasia",
"aloe",
"aloeaceae",
"aloes",
"aloha",
"aloneness",
"alonso",
"aloofness",
"alopecia",
"alopecurus",
"alopex",
"alopiidae",
"alopius",
"alosa",
"alouatta",
"alpaca",
"alpena",
"alpenstock",
"alpha",
"alphabet",
"alphabetisation",
"alphabetiser",
"alphabetization",
"alphabetizer",
"alphanumerics",
"alphavirus",
"alpinia",
"alpinism",
"alpinist",
"alprazolam",
"alps",
"alsace",
"alsatia",
"alsatian",
"alsobia",
"alsophila",
"alstonia",
"alstroemeria",
"altace",
"altaic",
"altair",
"altar",
"altarpiece",
"altazimuth",
"alterability",
"alteration",
"altercation",
"altering",
"alternanthera",
"alternate",
"alternation",
"alternative",
"alternator",
"althaea",
"althea",
"altimeter",
"altitude",
"alto",
"altocumulus",
"altogether",
"altoist",
"altoona",
"altostratus",
"altruism",
"altruist",
"alula",
"alum",
"alumbloom",
"alumina",
"aluminate",
"aluminium",
"aluminum",
"alumna",
"alumnus",
"alumroot",
"alundum",
"alupent",
"alveolar",
"alveolitis",
"alveolus",
"alyssum",
"alytes",
"alzheimers",
"amadavat",
"amaethon",
"amah",
"amalgam",
"amalgamation",
"amalgamator",
"amanita",
"amanuensis",
"amaranth",
"amaranthaceae",
"amaranthus",
"amarelle",
"amaretto",
"amarillo",
"amaryllidaceae",
"amaryllis",
"amastia",
"amaterasu",
"amateur",
"amateurishness",
"amateurism",
"amati",
"amativeness",
"amatungulu",
"amauropelta",
"amaurosis",
"amazement",
"amazon",
"amazona",
"ambage",
"ambages",
"ambassador",
"ambassadorship",
"ambassadress",
"amber",
"amberbell",
"amberboa",
"amberfish",
"ambergris",
"amberjack",
"ambiance",
"ambidexterity",
"ambience",
"ambiguity",
"ambit",
"ambition",
"ambitiousness",
"ambivalence",
"ambivalency",
"ambiversion",
"amble",
"ambler",
"ambloplites",
"amblygonite",
"amblyopia",
"amblyrhynchus",
"ambo",
"amboyna",
"ambrose",
"ambrosia",
"ambrosiaceae",
"ambulacrum",
"ambulance",
"ambulation",
"ambulatory",
"ambuscade",
"ambush",
"ambusher",
"ambystoma",
"ambystomatidae",
"ambystomid",
"ameba",
"amebiasis",
"amebiosis",
"ameer",
"ameiuridae",
"ameiurus",
"amelanchier",
"amelia",
"amelioration",
"ameloblast",
"amelogenesis",
"amen",
"amenability",
"amenableness",
"amendment",
"amends",
"amenia",
"amenities",
"amenity",
"amenorrhea",
"amenorrhoea",
"ament",
"amentia",
"amentiferae",
"amercement",
"america",
"american",
"americana",
"americanisation",
"americanism",
"americanization",
"americium",
"amerind",
"amerindian",
"amethopterin",
"amethyst",
"ametria",
"ametropia",
"amex",
"amhara",
"amharic",
"amia",
"amiability",
"amiableness",
"amianthum",
"amicability",
"amicableness",
"amide",
"amidopyrine",
"amigo",
"amiidae",
"amine",
"amino",
"aminoaciduria",
"aminoalkane",
"aminobenzine",
"aminomethane",
"aminopherase",
"aminophylline",
"aminoplast",
"aminopyrine",
"amiodarone",
"amir",
"amish",
"amitosis",
"amitriptyline",
"amity",
"amman",
"ammeter",
"ammine",
"ammo",
"ammobium",
"ammodytes",
"ammodytidae",
"ammonia",
"ammoniac",
"ammonification",
"ammonite",
"ammonium",
"ammoniuria",
"ammonoid",
"ammotragus",
"ammunition",
"amnesia",
"amnesiac",
"amnesic",
"amnesty",
"amnio",
"amniocentesis",
"amnion",
"amnios",
"amniota",
"amniote",
"amobarbital",
"amoeba",
"amoebiasis",
"amoebida",
"amoebina",
"amoebiosis",
"amon",
"amontillado",
"amor",
"amora",
"amoralism",
"amoralist",
"amorality",
"amorist",
"amorousness",
"amorpha",
"amorphophallus",
"amortisation",
"amortization",
"amos",
"amount",
"amour",
"amoxicillin",
"amoxil",
"amoy",
"amperage",
"ampere",
"ampersand",
"amphetamine",
"amphibia",
"amphibian",
"amphibole",
"amphibolips",
"amphibolite",
"amphibology",
"amphiboly",
"amphibrach",
"amphicarpa",
"amphicarpaea",
"amphictyony",
"amphidiploid",
"amphidiploidy",
"amphigory",
"amphimixis",
"amphineura",
"amphioxidae",
"amphioxus",
"amphipod",
"amphipoda",
"amphiprion",
"amphisbaena",
"amphisbaenia",
"amphisbaenidae",
"amphitheater",
"amphitheatre",
"amphiuma",
"amphiumidae",
"amphora",
"amphotericin",
"ampicillin",
"ampleness",
"amplification",
"amplifier",
"amplitude",
"ampoule",
"ampul",
"ampule",
"ampulla",
"amputation",
"amputator",
"amputee",
"amrinone",
"amsinckia",
"amsonia",
"amsterdam",
"amulet",
"amun",
"amundsen",
"amur",
"amusd",
"amusement",
"amygdala",
"amygdalaceae",
"amygdalin",
"amygdaloid",
"amygdalotomy",
"amygdalus",
"amyl",
"amylase",
"amyloid",
"amyloidosis",
"amylolysis",
"amylum",
"amyotonia",
"amyotrophia",
"amyotrophy",
"amytal",
"amyxia",
"anabantidae",
"anabaptism",
"anabaptist",
"anabas",
"anabiosis",
"anabolism",
"anabrus",
"anacanthini",
"anacardiaceae",
"anacardium",
"anachronism",
"anaclisis",
"anacoluthia",
"anacoluthon",
"anaconda",
"anacyclus",
"anadenanthera",
"anadiplosis",
"anaemia",
"anaerobe",
"anaesthesia",
"anaesthetic",
"anaesthetist",
"anagallis",
"anagasta",
"anaglyph",
"anaglyphy",
"anagnost",
"anagoge",
"anagram",
"anagrams",
"anagyris",
"anaheim",
"analbuminemia",
"analecta",
"analects",
"analeptic",
"analgesia",
"analgesic",
"analog",
"analogist",
"analogue",
"analogy",
"analphabet",
"analphabetic",
"analphabetism",
"analysand",
"analyser",
"analysis",
"analyst",
"analyticity",
"analyzer",
"anamnesis",
"anamorphism",
"anamorphosis",
"ananas",
"ananias",
"anapaest",
"anapest",
"anaphalis",
"anaphase",
"anaphor",
"anaphora",
"anaphrodisia",
"anaphylaxis",
"anaplasia",
"anaplasmosis",
"anaplasty",
"anaprox",
"anapsid",
"anapsida",
"anapurna",
"anarchism",
"anarchist",
"anarchy",
"anarhichadidae",
"anarhichas",
"anarthria",
"anas",
"anasa",
"anasarca",
"anasazi",
"anaspid",
"anaspida",
"anastalsis",
"anastatica",
"anastigmat",
"anastomosis",
"anastomus",
"anastrophe",
"anastylosis",
"anathema",
"anatidae",
"anatolia",
"anatolian",
"anatomical",
"anatomist",
"anatomy",
"anatotitan",
"anatoxin",
"anaxagoras",
"anaximander",
"anaximenes",
"ancestor",
"ancestress",
"ancestry",
"anchor",
"anchorage",
"anchorite",
"anchorman",
"anchorperson",
"anchovy",
"anchusa",
"anchylosis",
"ancient",
"ancientness",
"ancients",
"ancistrodon",
"ancohuma",
"ancylidae",
"ancylus",
"andalucia",
"andalusia",
"andante",
"andelmin",
"andersen",
"anderson",
"andes",
"andesite",
"andira",
"andiron",
"andorra",
"andorran",
"andradite",
"andreaea",
"andreaeales",
"andrena",
"andrenid",
"andrenidae",
"andrew",
"andrews",
"andricus",
"androecium",
"androgen",
"androgenesis",
"androgeny",
"androglossia",
"androgyne",
"androgyny",
"android",
"andromeda",
"androphobia",
"andropogon",
"androsterone",
"andryala",
"andvari",
"anecdote",
"anecdotist",
"aneides",
"anemia",
"anemography",
"anemometer",
"anemometry",
"anemone",
"anemonella",
"anemopsis",
"anencephalia",
"anencephaly",
"anergy",
"aneroid",
"anesthesia",
"anesthesiology",
"anesthetic",
"anesthetist",
"anesthyl",
"anestrum",
"anestrus",
"anethum",
"aneuploidy",
"aneurin",
"aneurism",
"aneurysm",
"angara",
"angas",
"angel",
"angelfish",
"angelica",
"angelim",
"angelique",
"angelology",
"angelus",
"anger",
"angevin",
"angevine",
"angiitis",
"angina",
"angiocardiogram",
"angiocarp",
"angioedema",
"angiogenesis",
"angiogram",
"angiography",
"angiohemophilia",
"angiologist",
"angiology",
"angioma",
"angiopathy",
"angioplasty",
"angiopteris",
"angiosarcoma",
"angioscope",
"angiosperm",
"angiospermae",
"angiotelectasia",
"angiotensin",
"angiotonin",
"angle",
"angledozer",
"angler",
"anglerfish",
"anglesea",
"anglesey",
"anglewing",
"angleworm",
"anglia",
"anglian",
"anglican",
"anglicanism",
"anglicisation",
"anglicism",
"anglicization",
"angling",
"anglomania",
"anglophil",
"anglophile",
"anglophilia",
"anglophobe",
"anglophobia",
"angola",
"angolan",
"angolese",
"angora",
"angostura",
"angraecum",
"angrecum",
"angriness",
"angst",
"angstrom",
"anguidae",
"anguilla",
"anguillan",
"anguillidae",
"anguilliformes",
"anguillula",
"anguis",
"anguish",
"angularity",
"angulation",
"angus",
"angwantibo",
"anhedonia",
"anhidrosis",
"anhima",
"anhimidae",
"anhinga",
"anhingidae",
"anhydride",
"anhydrosis",
"anigozanthus",
"anil",
"aniline",
"anima",
"animadversion",
"animal",
"animalcule",
"animalculum",
"animalia",
"animalisation",
"animalism",
"animality",
"animalization",
"animateness",
"animation",
"animatism",
"animator",
"animatronics",
"anime",
"animism",
"animist",
"animosity",
"animus",
"anion",
"anionic",
"anise",
"aniseed",
"aniseikonia",
"anisette",
"anisogamete",
"anisogamy",
"anisometropia",
"anisoptera",
"anisotremus",
"anisotropy",
"anjou",
"ankara",
"ankle",
"anklebone",
"anklet",
"anklets",
"ankus",
"ankyloglossia",
"ankylosaur",
"ankylosaurus",
"ankylosis",
"anlage",
"anna",
"annaba",
"annalist",
"annals",
"annam",
"annamese",
"annamite",
"annapolis",
"annapurna",
"anne",
"annealing",
"annelid",
"annelida",
"annex",
"annexa",
"annexation",
"annexe",
"anniellidae",
"annihilation",
"annihilator",
"anniversary",
"annon",
"annona",
"annonaceae",
"annotating",
"annotation",
"annotator",
"announcement",
"announcer",
"annoyance",
"annoyer",
"annoying",
"annual",
"annualry",
"annuitant",
"annuity",
"annulet",
"annulment",
"annulus",
"annum",
"annunciation",
"annunciator",
"annwfn",
"annwn",
"anoa",
"anobiidae",
"anode",
"anodonta",
"anodyne",
"anoectochilus",
"anoestrum",
"anoestrus",
"anogramma",
"anointer",
"anointing",
"anointment",
"anole",
"anolis",
"anomala",
"anomalist",
"anomalopidae",
"anomalops",
"anomalopteryx",
"anomalousness",
"anomaly",
"anomia",
"anomie",
"anomiidae",
"anomy",
"anonym",
"anonymity",
"anopheles",
"anopheline",
"anopia",
"anoplura",
"anorak",
"anorchia",
"anorchidism",
"anorchism",
"anorectic",
"anorexia",
"anorexic",
"anorgasmia",
"anorthite",
"anorthography",
"anorthopia",
"anosmia",
"anostraca",
"anouilh",
"anova",
"anovulant",
"anovulation",
"anoxemia",
"anoxia",
"anpu",
"ansaid",
"anselm",
"anser",
"anseres",
"anseriformes",
"anserinae",
"anshar",
"answer",
"answerability",
"answerableness",
"answerer",
"antabuse",
"antacid",
"antagonism",
"antagonist",
"antakiya",
"antakya",
"antalya",
"antananarivo",
"antapex",
"antarctic",
"antarctica",
"antares",
"antbird",
"ante",
"anteater",
"antecedence",
"antecedency",
"antecedent",
"antechamber",
"antediluvian",
"antedon",
"antedonidae",
"antefix",
"antelope",
"antenna",
"antennaria",
"antennariidae",
"antepenult",
"antepenultima",
"antepenultimate",
"anterior",
"anteriority",
"anteroom",
"anthelminthic",
"anthelmintic",
"anthem",
"anthemis",
"anther",
"antheraea",
"anthericum",
"antheridiophore",
"antheridium",
"antheropeas",
"antherozoid",
"anthesis",
"anthidium",
"anthill",
"anthoceropsida",
"anthoceros",
"anthocerotaceae",
"anthocerotales",
"anthologist",
"anthology",
"anthonomus",
"anthony",
"anthophyllite",
"anthophyta",
"anthozoa",
"anthozoan",
"anthracite",
"anthracosis",
"anthrax",
"anthriscus",
"anthropogenesis",
"anthropogeny",
"anthropoid",
"anthropoidea",
"anthropolatry",
"anthropologist",
"anthropology",
"anthropometry",
"anthropophagite",
"anthropophagus",
"anthropophagy",
"anthroposophy",
"anthurium",
"anthus",
"anthyllis",
"anti",
"antiacid",
"antiaircraft",
"antialiasing",
"antiarrhythmic",
"antibacterial",
"antibaryon",
"antibiosis",
"antibiotic",
"antibody",
"antic",
"anticatalyst",
"anticholinergic",
"antichrist",
"anticipant",
"anticipation",
"anticipator",
"anticlimax",
"anticoagulant",
"anticoagulation",
"anticonvulsant",
"anticyclone",
"antidepressant",
"antidiabetic",
"antidiarrheal",
"antidiuretic",
"antido",
"antidorcas",
"antidote",
"antielectron",
"antiemetic",
"antiepileptic",
"antifeminism",
"antifeminist",
"antiflatulent",
"antifreeze",
"antifungal",
"antigen",
"antigone",
"antigonia",
"antigonus",
"antigram",
"antigua",
"antiguan",
"antihero",
"antihistamine",
"antiknock",
"antilepton",
"antilles",
"antilocapra",
"antilocapridae",
"antilog",
"antilogarithm",
"antilope",
"antimacassar",
"antimalarial",
"antimatter",
"antimeson",
"antimetabolite",
"antimicrobial",
"antimicrobic",
"antimony",
"antimuon",
"antimycin",
"antimycotic",
"antineoplastic",
"antineutrino",
"antineutron",
"antinode",
"antinomasia",
"antinomian",
"antinomianism",
"antinomy",
"antioch",
"antioxidant",
"antiparticle",
"antipasto",
"antipathy",
"antiperspirant",
"antiphon",
"antiphonal",
"antiphonary",
"antiphony",
"antiphrasis",
"antipodal",
"antipode",
"antipodes",
"antipope",
"antiproton",
"antiprotozoal",
"antipruritic",
"antipsychotic",
"antipyresis",
"antipyretic",
"antiquarian",
"antiquark",
"antiquary",
"antique",
"antiquity",
"antirrhinum",
"antisemitism",
"antisepsis",
"antiseptic",
"antiserum",
"antispasmodic",
"antistrophe",
"antisyphilitic",
"antitauon",
"antithesis",
"antitoxin",
"antitrade",
"antitrades",
"antitussive",
"antitype",
"antivenene",
"antivenin",
"antivert",
"antiviral",
"antler",
"antlia",
"antlion",
"antofagasta",
"antoninus",
"antonius",
"antony",
"antonym",
"antonymy",
"antrozous",
"antrum",
"antum",
"antwerp",
"antwerpen",
"anubis",
"anunnaki",
"anura",
"anuran",
"anuresis",
"anuria",
"anus",
"anvers",
"anvil",
"anxiety",
"anxiolytic",
"anxiousness",
"anzac",
"anzio",
"aorist",
"aorta",
"aortitis",
"aotus",
"aoudad",
"apache",
"apadana",
"apalachicola",
"apanage",
"apar",
"apartheid",
"apartment",
"apathy",
"apatite",
"apatosaur",
"apatosaurus",
"apatura",
"apeldoorn",
"apennines",
"aper",
"apercu",
"aperea",
"aperient",
"aperitif",
"aperture",
"apery",
"apex",
"aphaeresis",
"aphagia",
"aphakia",
"aphakic",
"aphanite",
"aphasia",
"aphasic",
"aphasmidia",
"aphelion",
"apheresis",
"aphesis",
"aphid",
"aphididae",
"aphidoidea",
"aphis",
"aphonia",
"aphorism",
"aphorist",
"aphriza",
"aphrodisia",
"aphrodisiac",
"aphrodite",
"aphrophora",
"aphyllanthaceae",
"aphyllanthes",
"aphyllophorales",
"apia",
"apiaceae",
"apiarist",
"apiary",
"apiculture",
"apiculturist",
"apidae",
"apios",
"apis",
"apishamore",
"apium",
"aplacophora",
"aplacophoran",
"aplasia",
"aplectrum",
"aplite",
"aplodontia",
"aplodontiidae",
"aplomb",
"aplysia",
"aplysiidae",
"apnea",
"apoapsis",
"apocalypse",
"apocope",
"apocrypha",
"apocynaceae",
"apocynum",
"apodeme",
"apodemus",
"apodidae",
"apodiformes",
"apoenzyme",
"apogamy",
"apogee",
"apogon",
"apogonidae",
"apoidea",
"apojove",
"apolemia",
"apollinaire",
"apollo",
"apologetics",
"apologia",
"apologist",
"apologue",
"apology",
"apolune",
"apomict",
"apomixis",
"apomorphine",
"aponeurosis",
"apophasis",
"apophatism",
"apophthegm",
"apophysis",
"apoplexy",
"apoptosis",
"aporocactus",
"aposelene",
"aposiopesis",
"apostasy",
"apostate",
"apostle",
"apostleship",
"apostrophe",
"apothecary",
"apothecium",
"apothegm",
"apotheosis",
"appalachia",
"appalachian",
"appalachians",
"appalling",
"appaloosa",
"appanage",
"apparatchik",
"apparatus",
"apparel",
"apparency",
"apparentness",
"apparition",
"appeal",
"appealingness",
"appearance",
"appearing",
"appeasement",
"appeaser",
"appellant",
"appellation",
"appellative",
"appendage",
"appendectomy",
"appendicectomy",
"appendicitis",
"appendicle",
"appendicularia",
"appendix",
"appenzeller",
"apperception",
"appetence",
"appetency",
"appetiser",
"appetisingness",
"appetite",
"appetizer",
"appetizingness",
"applauder",
"applause",
"apple",
"applecart",
"applejack",
"applemint",
"applesauce",
"applet",
"appleton",
"applewood",
"appliance",
"applicability",
"applicant",
"application",
"applicator",
"applier",
"applique",
"appoggiatura",
"appointee",
"appointment",
"apportioning",
"apportionment",
"appositeness",
"apposition",
"appraisal",
"appraiser",
"appreciation",
"appreciator",
"apprehender",
"apprehension",
"apprentice",
"apprenticeship",
"apprisal",
"appro",
"approach",
"approachability",
"approaching",
"approbation",
"appropriateness",
"appropriation",
"appropriator",
"approval",
"approver",
"approving",
"approximation",
"appurtenance",
"apraxia",
"apresoline",
"apricot",
"april",
"apron",
"apse",
"apsis",
"apsu",
"aptenodytes",
"apterygidae",
"apterygiformes",
"apteryx",
"aptitude",
"aptness",
"apulia",
"apus",
"aqaba",
"aqua",
"aquaculture",
"aqualung",
"aquamarine",
"aquanaut",
"aquaphobia",
"aquaplane",
"aquarium",
"aquarius",
"aquatic",
"aquatics",
"aquatint",
"aquavit",
"aqueduct",
"aquiculture",
"aquifer",
"aquifoliaceae",
"aquila",
"aquilege",
"aquilegia",
"aquinas",
"aquitaine",
"aquitania",
"arab",
"arabesque",
"arabia",
"arabian",
"arabic",
"arabidopsis",
"arability",
"arabis",
"arabist",
"araceae",
"arachis",
"arachnid",
"arachnida",
"arachnoid",
"arachnophobia",
"arafat",
"aragon",
"aragonite",
"araguaia",
"araguaya",
"arak",
"arales",
"aralia",
"araliaceae",
"aram",
"aramaean",
"aramaic",
"arame",
"aramean",
"aramus",
"aranea",
"araneae",
"araneida",
"araneus",
"aranyaka",
"arapaho",
"arapahoe",
"ararat",
"arariba",
"araroba",
"aras",
"arauca",
"araucaria",
"araucariaceae",
"araujia",
"arava",
"arawak",
"arawakan",
"arawn",
"araxes",
"arbalest",
"arbalist",
"arbiter",
"arbitrage",
"arbitrager",
"arbitrageur",
"arbitrament",
"arbitrariness",
"arbitration",
"arbitrator",
"arbitrement",
"arbor",
"arboretum",
"arboriculture",
"arboriculturist",
"arborist",
"arborolatry",
"arborvirus",
"arborvitae",
"arbour",
"arbovirus",
"arbutus",
"arca",
"arcade",
"arcadia",
"arcadian",
"arcadic",
"arcanum",
"arccos",
"arccosecant",
"arccosine",
"arccotangent",
"arcdegree",
"arcella",
"arcellidae",
"arceuthobium",
"arch",
"archaebacteria",
"archaebacterium",
"archaeobacteria",
"archaeologist",
"archaeology",
"archaeopteryx",
"archaeornis",
"archaeornithes",
"archaeozoic",
"archaicism",
"archaism",
"archaist",
"archangel",
"archbishop",
"archbishopric",
"archdeacon",
"archdeaconry",
"archdiocese",
"archduchess",
"archduchy",
"archduke",
"archean",
"archegonium",
"archenteron",
"archeobacteria",
"archeologist",
"archeology",
"archeopteryx",
"archeozoic",
"archer",
"archerfish",
"archery",
"archespore",
"archesporium",
"archetype",
"archiannelid",
"archiannelida",
"archidiaconate",
"archidiskidon",
"archil",
"archilochus",
"archimandrite",
"archimedes",
"archine",
"archipallium",
"archipelago",
"architect",
"architectonics",
"architecture",
"architeuthis",
"architrave",
"archive",
"archives",
"archivist",
"archness",
"archosargus",
"archosaur",
"archosauria",
"archosaurian",
"archpriest",
"archway",
"arcidae",
"arcminute",
"arcsec",
"arcsecant",
"arcsecond",
"arcsin",
"arcsine",
"arctan",
"arctangent",
"arctic",
"arctictis",
"arctiid",
"arctiidae",
"arctium",
"arctocebus",
"arctocephalus",
"arctonyx",
"arctostaphylos",
"arctotis",
"arcturus",
"arcus",
"arda",
"ardea",
"ardeb",
"ardeidae",
"ardennes",
"ardisia",
"ardor",
"ardour",
"ards",
"arduousness",
"area",
"areaway",
"areca",
"arecaceae",
"arecidae",
"areflexia",
"arena",
"arenaria",
"arenaviridae",
"arenavirus",
"arendt",
"arenga",
"areola",
"areopagite",
"areopagus",
"arequipa",
"arere",
"ares",
"arete",
"arethusa",
"argal",
"argali",
"argasid",
"argasidae",
"argemone",
"argent",
"argentina",
"argentine",
"argentinian",
"argentinidae",
"argentinosaur",
"argentite",
"argil",
"argillite",
"arginine",
"argiope",
"argiopidae",
"argive",
"argo",
"argon",
"argonaut",
"argonauta",
"argonautidae",
"argonne",
"argonon",
"argos",
"argosy",
"argot",
"arguer",
"arguing",
"argument",
"argumentation",
"argun",
"argus",
"argusianus",
"argyle",
"argyll",
"argynnis",
"argyranthemum",
"argyreia",
"argyrodite",
"argyrol",
"argyrotaenia",
"argyroxiphium",
"arhant",
"arhat",
"arhus",
"aria",
"ariadne",
"ariana",
"arianism",
"arianist",
"arianrhod",
"arianrod",
"aricara",
"aridity",
"aridness",
"aries",
"arietta",
"ariidae",
"arikara",
"aril",
"arilus",
"ariocarpus",
"ariomma",
"arioso",
"arisaema",
"arisarum",
"arishth",
"arista",
"aristarchus",
"aristocort",
"aristocracy",
"aristocrat",
"aristolochia",
"aristolochiales",
"aristopak",
"aristophanes",
"aristotelean",
"aristotelia",
"aristotelian",
"aristotelianism",
"aristotle",
"arithmancy",
"arithmetic",
"arithmetician",
"arity",
"arius",
"arizona",
"arizonan",
"arizonian",
"arjuna",
"arkansan",
"arkansas",
"arkansawyer",
"arles",
"arlington",
"armada",
"armadillidiidae",
"armadillidium",
"armadillo",
"armageddon",
"armagnac",
"armament",
"armamentarium",
"armature",
"armband",
"armchair",
"armenia",
"armenian",
"armeria",
"armet",
"armful",
"armguard",
"armhole",
"armiger",
"armilla",
"armillaria",
"armillariella",
"armin",
"arming",
"arminian",
"arminianism",
"arminius",
"armistice",
"armlet",
"armoire",
"armor",
"armoracia",
"armorer",
"armory",
"armour",
"armourer",
"armoury",
"armpit",
"armrest",
"arms",
"armstrong",
"army",
"armyworm",
"arng",
"arnhem",
"arnica",
"arno",
"arnold",
"arnoseris",
"aroid",
"aroma",
"aromatherapy",
"arouet",
"arousal",
"arouser",
"arpeggio",
"arpent",
"arquebus",
"arrack",
"arraignment",
"arrangement",
"arranger",
"arranging",
"arras",
"array",
"arrears",
"arrest",
"arrester",
"arrhenatherum",
"arrhenius",
"arrhythmia",
"arrival",
"arrivederci",
"arriver",
"arriviste",
"arroba",
"arrogance",
"arrogation",
"arrogator",
"arrow",
"arrowhead",
"arrowroot",
"arrowsmith",
"arrowworm",
"arroyo",
"arse",
"arsehole",
"arsenal",
"arsenate",
"arsenic",
"arsenical",
"arsenide",
"arsenopyrite",
"arsine",
"arson",
"arsonist",
"artamidae",
"artamus",
"artaxerxes",
"artefact",
"artemia",
"artemis",
"artemisia",
"arteria",
"arteriectasia",
"arteriectasis",
"arteriogram",
"arteriography",
"arteriola",
"arteriole",
"arteritis",
"artery",
"artfulness",
"arthralgia",
"arthritic",
"arthritis",
"arthrocentesis",
"arthrodesis",
"arthrogram",
"arthrography",
"arthromere",
"arthropathy",
"arthroplasty",
"arthropod",
"arthropoda",
"arthropteris",
"arthroscope",
"arthroscopy",
"arthrospore",
"arthur",
"artichoke",
"article",
"articulateness",
"articulatio",
"articulation",
"articulator",
"artifact",
"artifice",
"artificer",
"artificiality",
"artillery",
"artilleryman",
"artiodactyl",
"artiodactyla",
"artisan",
"artist",
"artiste",
"artistry",
"artlessness",
"artocarpus",
"artois",
"arts",
"artsd",
"artwork",
"aruba",
"arugula",
"arui",
"arulo",
"arum",
"arundinaria",
"arundo",
"aruru",
"arvicola",
"aryan",
"arytaenoid",
"arytenoid",
"asadha",
"asafetida",
"asafoetida",
"asahikawa",
"asala",
"asama",
"asamiya",
"asana",
"asanga",
"asarabacca",
"asarh",
"asarum",
"asbestos",
"asbestosis",
"ascaphidae",
"ascaphus",
"ascariasis",
"ascaridae",
"ascaridia",
"ascaris",
"ascendance",
"ascendancy",
"ascendant",
"ascendence",
"ascendency",
"ascendent",
"ascender",
"ascending",
"ascension",
"ascent",
"ascesis",
"ascetic",
"asceticism",
"asch",
"aschelminthes",
"ascidiaceae",
"ascidian",
"ascii",
"ascites",
"asclepiad",
"asclepiadaceae",
"asclepias",
"asclepius",
"ascocarp",
"ascolichen",
"ascoma",
"ascomycete",
"ascomycetes",
"ascomycota",
"ascomycotina",
"ascophyllum",
"ascospore",
"ascot",
"ascription",
"ascus",
"asdic",
"asean",
"asepsis",
"asexuality",
"asgard",
"ashbin",
"ashcake",
"ashcan",
"ashe",
"asheville",
"ashir",
"ashkenazi",
"ashkhabad",
"ashlar",
"ashram",
"ashton",
"ashtoreth",
"ashtray",
"ashur",
"ashurbanipal",
"asia",
"asian",
"asiatic",
"aside",
"asilidae",
"asimina",
"asimov",
"asin",
"asininity",
"asio",
"asker",
"asking",
"asklepios",
"asmara",
"asmera",
"aspadana",
"aspalathus",
"asparagaceae",
"asparaginase",
"asparagine",
"asparagus",
"aspartame",
"aspect",
"aspen",
"asper",
"aspergill",
"aspergillaceae",
"aspergillales",
"aspergillosis",
"aspergillus",
"asperity",
"aspersion",
"aspersorium",
"asperula",
"asphalt",
"asphodel",
"asphodelaceae",
"asphodeline",
"asphodelus",
"asphyxia",
"asphyxiation",
"asphyxiator",
"aspic",
"aspidelaps",
"aspidiotus",
"aspidistra",
"aspidophoroides",
"aspinwall",
"aspirant",
"aspirate",
"aspiration",
"aspirator",
"aspirer",
"aspirin",
"aspis",
"aspleniaceae",
"asplenium",
"assagai",
"assailability",
"assailant",
"assam",
"assamese",
"assassin",
"assassination",
"assassinator",
"assault",
"assaulter",
"assay",
"assayer",
"assegai",
"assemblage",
"assembler",
"assembling",
"assembly",
"assemblyman",
"assemblywoman",
"assent",
"assenter",
"assenting",
"asserter",
"assertion",
"assertiveness",
"assessee",
"assessment",
"assessor",
"asset",
"assets",
"asseveration",
"asseverator",
"asshole",
"assibilation",
"assiduity",
"assiduousness",
"assignation",
"assignee",
"assigning",
"assignment",
"assignor",
"assimilation",
"assimilator",
"assist",
"assistance",
"assistant",
"assize",
"assizes",
"associability",
"associableness",
"associate",
"associateship",
"association",
"associationism",
"assonance",
"assortment",
"assouan",
"assuagement",
"assuan",
"assumption",
"assur",
"assurance",
"assurbanipal",
"assuredness",
"assyria",
"assyrian",
"assyriology",
"astacidae",
"astacura",
"astacus",
"astaire",
"astana",
"astarte",
"astasia",
"astatine",
"aster",
"asteraceae",
"astereognosis",
"asteridae",
"asterion",
"asterisk",
"asterism",
"asteroid",
"asteroidea",
"asterope",
"asthenia",
"asthenopia",
"asthenosphere",
"astheny",
"asthma",
"asthmatic",
"astigmatism",
"astigmia",
"astilbe",
"astonishment",
"astor",
"astragal",
"astragalus",
"astrakhan",
"astrantia",
"astraphobia",
"astreus",
"astringence",
"astringency",
"astringent",
"astrobiology",
"astrocyte",
"astrodome",
"astrodynamics",
"astrogator",
"astroglia",
"astrolabe",
"astrolatry",
"astrologer",
"astrologist",
"astrology",
"astroloma",
"astrometry",
"astronaut",
"astronautics",
"astronavigation",
"astronium",
"astronomer",
"astronomy",
"astrophysicist",
"astrophysics",
"astrophyton",
"astropogon",
"astuteness",
"asuncion",
"asur",
"asura",
"asurbanipal",
"asvina",
"asvins",
"aswan",
"asylum",
"asymmetry",
"asymptote",
"asynchronism",
"asynchrony",
"asynclitism",
"asyndeton",
"asynergia",
"asynergy",
"asystole",
"atabrine",
"atakapa",
"atakapan",
"atar",
"ataractic",
"atarax",
"ataraxia",
"ataraxis",
"ataturk",
"atavism",
"atavist",
"ataxia",
"ataxy",
"atayalic",
"atelectasis",
"ateleiosis",
"ateles",
"atelier",
"ateliosis",
"aten",
"atenolol",
"athabascan",
"athabaskan",
"athanasianism",
"athanasius",
"athanor",
"athapascan",
"athapaskan",
"athar",
"atheism",
"atheist",
"athelstan",
"athena",
"athenaeum",
"athene",
"atheneum",
"athenian",
"athens",
"atherinidae",
"atherinopsis",
"atherodyde",
"atherogenesis",
"atheroma",
"atherosclerosis",
"atherurus",
"athetosis",
"athinai",
"athiorhodaceae",
"athlete",
"athleticism",
"athletics",
"athodyd",
"athos",
"athrotaxis",
"athyriaceae",
"athyrium",
"ativan",
"atlanta",
"atlantic",
"atlantides",
"atlantis",
"atlas",
"atmometer",
"atmosphere",
"atmospherics",
"atole",
"atoll",
"atom",
"atomisation",
"atomiser",
"atomism",
"atomization",
"atomizer",
"aton",
"atonalism",
"atonality",
"atonement",
"atonia",
"atonicity",
"atony",
"atopognosia",
"atopognosis",
"atopy",
"atorvastatin",
"atrazine",
"atresia",
"atreus",
"atrichornis",
"atriplex",
"atrium",
"atrociousness",
"atrocity",
"atropa",
"atrophedema",
"atrophy",
"atropidae",
"atropine",
"atropos",
"atrovent",
"atsugewi",
"attacapa",
"attacapan",
"attache",
"attachment",
"attack",
"attacker",
"attainability",
"attainableness",
"attainder",
"attainment",
"attalea",
"attar",
"attempt",
"attempter",
"attendance",
"attendant",
"attendee",
"attender",
"attending",
"attention",
"attentiveness",
"attenuation",
"attenuator",
"attestant",
"attestation",
"attestator",
"attester",
"attestor",
"attic",
"attica",
"atticus",
"attila",
"attilio",
"attire",
"attitude",
"attlee",
"attorney",
"attorneyship",
"attosecond",
"attracter",
"attraction",
"attractiveness",
"attractor",
"attribute",
"attribution",
"attrition",
"atypicality",
"auberge",
"aubergine",
"auchincloss",
"auckland",
"auction",
"auctioneer",
"aucuba",
"audaciousness",
"audacity",
"audad",
"auden",
"audibility",
"audible",
"audibleness",
"audience",
"audile",
"audio",
"audiocassette",
"audiogram",
"audiology",
"audiometer",
"audiometry",
"audiotape",
"audiovisual",
"audit",
"audition",
"auditor",
"auditorium",
"audubon",
"augeas",
"augend",
"auger",
"aught",
"augite",
"augmentation",
"augmentin",
"augur",
"augury",
"august",
"augusta",
"augustine",
"augustinian",
"augustus",
"auklet",
"aulacorhyncus",
"aulostomidae",
"aulostomus",
"aunt",
"auntie",
"aunty",
"aura",
"aurelius",
"aureolaria",
"aureole",
"aureomycin",
"auricle",
"auricula",
"auriculare",
"auricularia",
"auriculariaceae",
"auriculariales",
"auriga",
"auriparus",
"auriscope",
"aurochs",
"aurora",
"auroscope",
"auschwitz",
"auscultation",
"auspex",
"auspice",
"auspices",
"auspiciousness",
"aussie",
"austen",
"austenite",
"austereness",
"austerity",
"austerlitz",
"austin",
"austral",
"australasia",
"australia",
"australian",
"austria",
"austrian",
"austrocedrus",
"austronesia",
"austronesian",
"austrotaxus",
"autacoid",
"autarchy",
"autarky",
"auteur",
"authentication",
"authenticator",
"authenticity",
"author",
"authoress",
"authorisation",
"authoriser",
"authoritarian",
"authorities",
"authority",
"authorization",
"authorizer",
"authorship",
"autism",
"auto",
"autoantibody",
"autobahn",
"autobiographer",
"autobiography",
"autobus",
"autocatalysis",
"autochthon",
"autochthony",
"autoclave",
"autocoid",
"autocracy",
"autocrat",
"autocue",
"autodidact",
"autoeroticism",
"autoerotism",
"autofocus",
"autogamy",
"autogenesis",
"autogenics",
"autogeny",
"autogiro",
"autograft",
"autograph",
"autogyro",
"autoimmunity",
"autoinjector",
"autolatry",
"autoloader",
"autolysis",
"automaker",
"automat",
"automatic",
"automation",
"automatism",
"automaton",
"automeris",
"automobile",
"automobilist",
"automysophobia",
"autonomy",
"autophyte",
"autopilot",
"autoplasty",
"autopsy",
"autoradiograph",
"autoradiography",
"autoregulation",
"autosexing",
"autosome",
"autostrada",
"autosuggestion",
"autotelism",
"autotomy",
"autotroph",
"autotype",
"autotypy",
"autumn",
"auvergne",
"auxesis",
"auxiliary",
"auxin",
"avadavat",
"avahi",
"avail",
"availability",
"availableness",
"avalanche",
"avalokiteshvara",
"avalokitesvara",
"avaram",
"avarice",
"avariciousness",
"avaritia",
"avatar",
"avena",
"avenger",
"avens",
"aventail",
"aventurine",
"avenue",
"average",
"averageness",
"averment",
"averrhoa",
"averroes",
"aversion",
"averting",
"aves",
"avesta",
"avestan",
"aviary",
"aviation",
"aviator",
"aviatress",
"aviatrix",
"avicenna",
"avicennia",
"avicenniaceae",
"avidity",
"avidness",
"avifauna",
"avignon",
"avionics",
"avitaminosis",
"avocado",
"avocation",
"avocet",
"avogadro",
"avoidance",
"avoirdupois",
"avon",
"avouchment",
"avowal",
"avower",
"avulsion",
"awakening",
"award",
"awarding",
"awareness",
"awayness",
"awfulness",
"awkwardness",
"awlwort",
"awning",
"awol",
"axerophthol",
"axil",
"axilla",
"axiology",
"axiom",
"axis",
"axle",
"axletree",
"axolemma",
"axolotl",
"axon",
"axone",
"axseed",
"ayah",
"ayapana",
"ayatollah",
"ayin",
"ayrshire",
"aythya",
"ayurveda",
"azactam",
"azadirachta",
"azadirachtin",
"azalea",
"azaleastrum",
"azathioprine",
"azedarach",
"azederach",
"azerbaijan",
"azerbaijani",
"azerbajdzhan",
"azeri",
"azide",
"azimuth",
"azithromycin",
"azoimide",
"azolla",
"azollaceae",
"azores",
"azotaemia",
"azote",
"azotemia",
"azoturia",
"aztec",
"aztecan",
"aztreonam",
"azure",
"azurite",
"azymia",
"baal",
"baas",
"baba",
"babar",
"babassu",
"babbitt",
"babbitting",
"babble",
"babbler",
"babbling",
"babe",
"babel",
"babesiidae",
"babinski",
"babiroussa",
"babirusa",
"babirussa",
"babka",
"baboo",
"baboon",
"babu",
"babushka",
"baby",
"babyhood",
"babylon",
"babylonia",
"babylonian",
"babyminder",
"babyrousa",
"babysitter",
"babysitting",
"babytalk",
"bacca",
"baccalaureate",
"baccarat",
"bacchanal",
"bacchanalia",
"bacchant",
"bacchante",
"baccharis",
"bacchus",
"baccy",
"bach",
"bachelor",
"bachelorette",
"bachelorhood",
"bacillaceae",
"bacillus",
"bacitracin",
"back",
"backache",
"backband",
"backbeat",
"backbench",
"backbencher",
"backbend",
"backbiter",
"backblast",
"backboard",
"backbone",
"backchat",
"backcloth",
"backdoor",
"backdown",
"backdrop",
"backer",
"backfield",
"backfire",
"backflow",
"backflowing",
"backgammon",
"background",
"backgrounder",
"backgrounding",
"backhand",
"backhander",
"backhoe",
"backing",
"backlash",
"backlighting",
"backlog",
"backpack",
"backpacker",
"backpacking",
"backplate",
"backrest",
"backroom",
"backsaw",
"backscratcher",
"backseat",
"backsheesh",
"backside",
"backslapper",
"backslider",
"backsliding",
"backspace",
"backspacer",
"backspin",
"backstage",
"backstairs",
"backstay",
"backstitch",
"backstop",
"backstroke",
"backstroker",
"backswimmer",
"backsword",
"backtalk",
"backup",
"backwardness",
"backwash",
"backwater",
"backwoods",
"backwoodsman",
"backyard",
"bacon",
"bacteremia",
"bacteria",
"bacteriacide",
"bacteriaemia",
"bactericide",
"bacteriemia",
"bacteriologist",
"bacteriology",
"bacteriolysis",
"bacteriophage",
"bacteriostasis",
"bacteriostat",
"bacterium",
"bacteroid",
"bacteroidaceae",
"bacteroides",
"badaga",
"baddeleyite",
"baddie",
"bade",
"badge",
"badger",
"badgerer",
"badgering",
"badinage",
"badlands",
"badminton",
"badness",
"baeda",
"baedeker",
"baffle",
"baffled",
"bafflement",
"bagascosis",
"bagasse",
"bagassosis",
"bagatelle",
"bagdad",
"bagel",
"bagful",
"baggage",
"baggageman",
"bagger",
"bagging",
"baghdad",
"bagman",
"bagnio",
"bagpipe",
"bagpiper",
"baguet",
"baguette",
"bahai",
"bahaism",
"bahamas",
"bahamian",
"bahasa",
"bahrain",
"bahraini",
"bahrein",
"bahreini",
"baht",
"baic",
"baikal",
"bail",
"bailee",
"bailey",
"bailiff",
"bailiffship",
"bailiwick",
"bailment",
"bailor",
"baiomys",
"bairava",
"bairdiella",
"bairiki",
"bairn",
"baisa",
"baisakh",
"bait",
"baiting",
"baiza",
"baize",
"bakeapple",
"bakehouse",
"bakelite",
"baker",
"bakersfield",
"bakery",
"bakeshop",
"baking",
"baklava",
"baksheesh",
"bakshis",
"bakshish",
"baku",
"bakunin",
"balaclava",
"balaena",
"balaeniceps",
"balaenidae",
"balaenoptera",
"balaenopteridae",
"balagan",
"balalaika",
"balance",
"balancer",
"balanchine",
"balancing",
"balanidae",
"balanitis",
"balanoposthitis",
"balanus",
"balarama",
"balas",
"balata",
"balaton",
"balboa",
"balbriggan",
"balcony",
"baldachin",
"balder",
"balderdash",
"baldhead",
"baldness",
"baldpate",
"baldr",
"baldric",
"baldrick",
"baldwin",
"baldy",
"bale",
"baleen",
"balefire",
"balefulness",
"balenciaga",
"balfour",
"bali",
"balibago",
"balinese",
"balistes",
"balistidae",
"balk",
"balkan",
"balkans",
"balker",
"balkiness",
"balkline",
"ball",
"ballad",
"ballade",
"balladeer",
"ballast",
"ballcock",
"balldress",
"ballerina",
"ballet",
"balletomane",
"balletomania",
"ballgame",
"ballista",
"ballistics",
"ballistite",
"ballock",
"balloon",
"balloonfish",
"ballooning",
"balloonist",
"ballot",
"ballota",
"balloting",
"ballottement",
"ballpark",
"ballpen",
"ballplayer",
"ballpoint",
"ballroom",
"ballup",
"ballyhoo",
"balm",
"balminess",
"balmoral",
"balochi",
"baloney",
"balsa",
"balsam",
"balsaminaceae",
"balsamorhiza",
"balsamroot",
"balthasar",
"balthazar",
"baltic",
"baltimore",
"baluchi",
"baluster",
"balusters",
"balustrade",
"balzac",
"bamako",
"bambino",
"bamboo",
"bambusa",
"bambuseae",
"banality",
"banana",
"band",
"bandage",
"bandaging",
"bandana",
"bandanna",
"bandbox",
"bandeau",
"bandelet",
"bandelette",
"banderilla",
"banderillero",
"bandicoot",
"banding",
"bandit",
"banditry",
"bandleader",
"bandlet",
"bandmaster",
"bandoleer",
"bandolier",
"bandoneon",
"bandsaw",
"bandsman",
"bandstand",
"bandtail",
"bandung",
"bandwagon",
"bandwidth",
"bandyleg",
"bane",
"baneberry",
"banff",
"bang",
"bangalore",
"banger",
"bangiaceae",
"banging",
"bangkok",
"bangla",
"bangladesh",
"bangladeshi",
"bangle",
"bangor",
"bangtail",
"bangui",
"banian",
"banishment",
"banister",
"banjo",
"banjul",
"bank",
"bankbook",
"banker",
"bankhead",
"bankia",
"banking",
"banknote",
"bankroll",
"bankrupt",
"bankruptcy",
"banks",
"banksia",
"banner",
"banneret",
"banning",
"bannister",
"bannock",
"bannockburn",
"banns",
"banquet",
"banqueting",
"banquette",
"banshee",
"banshie",
"bantam",
"bantamweight",
"banteng",
"banter",
"banting",
"bantu",
"banyan",
"banzai",
"baobab",
"baphia",
"baptisia",
"baptism",
"baptist",
"baptistery",
"baptistry",
"baptists",
"baraka",
"baranduki",
"barany",
"barb",
"barbacan",
"barbadian",
"barbados",
"barbarea",
"barbarian",
"barbarisation",
"barbarism",
"barbarity",
"barbarization",
"barbarossa",
"barbarousness",
"barbary",
"barbasco",
"barbecue",
"barbecuing",
"barbel",
"barbell",
"barbeque",
"barber",
"barberry",
"barbershop",
"barbet",
"barbette",
"barbican",
"barbital",
"barbitone",
"barbiturate",
"barbu",
"barbuda",
"barbwire",
"barcarole",
"barcarolle",
"barcelona",
"bard",
"bardeen",
"bardolatry",
"bareboat",
"bareboating",
"bareness",
"barf",
"bargain",
"bargainer",
"bargaining",
"barge",
"bargee",
"bargello",
"bargeman",
"bari",
"barilla",
"baring",
"barish",
"barite",
"baritone",
"barium",
"bark",
"barkeep",
"barkeeper",
"barker",
"barkley",
"barley",
"barleycorn",
"barm",
"barmaid",
"barman",
"barmbrack",
"barn",
"barnacle",
"barnburner",
"barndoor",
"barnful",
"barnstormer",
"barnum",
"barnyard",
"barograph",
"barometer",
"baron",
"baronage",
"baronduki",
"baroness",
"baronet",
"baronetage",
"baronetcy",
"barong",
"barony",
"baroque",
"baroqueness",
"baroreceptor",
"barosaur",
"barosaurus",
"barouche",
"barque",
"barrack",
"barracking",
"barracouta",
"barracuda",
"barrage",
"barramundi",
"barranquilla",
"barrater",
"barrator",
"barratry",
"barrel",
"barrelfish",
"barrelful",
"barrelhouse",
"barrels",
"barren",
"barrenness",
"barrenwort",
"barrette",
"barretter",
"barricade",
"barrie",
"barrier",
"barring",
"barrio",
"barrister",
"barroom",
"barrow",
"barrowful",
"barrymore",
"bars",
"barstow",
"bart",
"bartender",
"barter",
"barterer",
"barth",
"barthelme",
"bartholdi",
"bartholin",
"bartlesville",
"bartlett",
"bartok",
"bartonia",
"bartramia",
"baruch",
"barunduki",
"barycenter",
"barye",
"baryon",
"baryshnikov",
"baryta",
"barytes",
"barytone",
"basalt",
"bascule",
"base",
"baseball",
"baseboard",
"basel",
"baseline",
"basement",
"baseness",
"basenji",
"bash",
"bashfulness",
"basia",
"basic",
"basics",
"basidiocarp",
"basidiolichen",
"basidiomycete",
"basidiomycetes",
"basidiomycota",
"basidiomycotina",
"basidiospore",
"basidium",
"basil",
"basileus",
"basilica",
"basilicata",
"basiliscus",
"basilisk",
"basin",
"basinet",
"basinful",
"basis",
"basket",
"basketball",
"basketeer",
"basketful",
"basketmaker",
"basketry",
"basketweaver",
"basle",
"basophil",
"basophile",
"basophilia",
"basotho",
"basque",
"basra",
"bass",
"bassariscidae",
"bassariscus",
"bassarisk",
"basset",
"basseterre",
"bassia",
"bassine",
"bassinet",
"bassist",
"basso",
"bassoon",
"bassoonist",
"basswood",
"bast",
"bastard",
"bastardisation",
"bastardization",
"bastardy",
"baste",
"baster",
"bastille",
"bastinado",
"basting",
"bastion",
"bastnaesite",
"bastnasite",
"basuco",
"basuto",
"basutoland",
"bata",
"bataan",
"batch",
"batfish",
"bath",
"bathe",
"bather",
"bathhouse",
"bathing",
"batholite",
"batholith",
"bathometer",
"bathos",
"bathrobe",
"bathroom",
"bathsheba",
"bathtub",
"bathyergidae",
"bathyergus",
"bathymeter",
"bathymetry",
"bathyscape",
"bathyscaph",
"bathyscaphe",
"bathysphere",
"batidaceae",
"batik",
"batis",
"batiste",
"batman",
"batna",
"batoidei",
"baton",
"batrachia",
"batrachian",
"batrachoididae",
"batrachoseps",
"batsman",
"batswana",
"battalion",
"batten",
"batter",
"battercake",
"battering",
"battery",
"batting",
"battle",
"battledore",
"battlefield",
"battlefront",
"battleground",
"battlement",
"battler",
"battleship",
"battlesight",
"battlewagon",
"battue",
"batwing",
"bauble",
"baud",
"baudelaire",
"bauhaus",
"bauhinia",
"baulk",
"baulker",
"baum",
"bauxite",
"bavaria",
"bavarian",
"bawbee",
"bawd",
"bawdiness",
"bawdry",
"bawdy",
"bawdyhouse",
"bawler",
"bawling",
"baya",
"bayard",
"bayat",
"bayberry",
"baycol",
"bayer",
"bayes",
"baykal",
"bayonet",
"bayonne",
"bayou",
"bayrut",
"bazaar",
"bazar",
"bazillion",
"bazooka",
"bdellium",
"beach",
"beachball",
"beachcomber",
"beachfront",
"beachhead",
"beachwear",
"beacon",
"bead",
"beading",
"beadle",
"beads",
"beadsman",
"beadwork",
"beagle",
"beagling",
"beak",
"beaker",
"beam",
"bean",
"beanbag",
"beanball",
"beaner",
"beanfeast",
"beanie",
"beano",
"beanstalk",
"beantown",
"beany",
"bear",
"bearberry",
"bearcat",
"beard",
"bearer",
"bearing",
"bearnaise",
"bearskin",
"bearwood",
"beast",
"beastliness",
"beat",
"beater",
"beatification",
"beating",
"beatitude",
"beatles",
"beatnik",
"beatniks",
"beatrice",
"beats",
"beau",
"beaugregory",
"beaujolais",
"beaumont",
"beaumontia",
"beaut",
"beauteousness",
"beautician",
"beautification",
"beauty",
"beauvoir",
"beaver",
"beaverbrook",
"bebop",
"bechamel",
"bechuana",
"beck",
"becket",
"beckett",
"beckley",
"becomingness",
"becquerel",
"beda",
"bedbug",
"bedchamber",
"bedclothes",
"bedcover",
"bedder",
"bedding",
"bede",
"bedesman",
"bedevilment",
"bedfellow",
"bedframe",
"bedground",
"bedlam",
"bedlamite",
"bedouin",
"bedpan",
"bedpost",
"bedrest",
"bedrock",
"bedroll",
"bedroom",
"bedside",
"bedsit",
"bedsitter",
"bedsore",
"bedspread",
"bedspring",
"bedstead",
"bedstraw",
"bedtime",
"beduin",
"bedwetter",
"beebalm",
"beebread",
"beech",
"beecher",
"beechnut",
"beechwood",
"beef",
"beefalo",
"beefburger",
"beefcake",
"beefeater",
"beefsteak",
"beefwood",
"beehive",
"beekeeper",
"beekeeping",
"beeline",
"beelzebub",
"beep",
"beeper",
"beer",
"beerbohm",
"beeswax",
"beet",
"beethoven",
"beetle",
"beetleweed",
"beetroot",
"befooling",
"befoulment",
"befuddlement",
"begetter",
"beggar",
"beggarman",
"beggarweed",
"beggarwoman",
"beggary",
"begging",
"begin",
"beginner",
"beginning",
"begonia",
"begoniaceae",
"beguilement",
"beguiler",
"beguine",
"begum",
"behalf",
"behavior",
"behaviorism",
"behaviorist",
"behaviour",
"behaviourism",
"behaviourist",
"beheading",
"behemoth",
"behest",
"behind",
"behmen",
"behmenism",
"beholder",
"beholding",
"behrens",
"behring",
"beige",
"beigel",
"beignet",
"beijing",
"being",
"beingness",
"beira",
"beirut",
"belamcanda",
"belarus",
"belarusian",
"belau",
"belay",
"belch",
"belching",
"beldam",
"beldame",
"beleaguering",
"belem",
"belemnite",
"belemnitidae",
"belemnoidea",
"belfast",
"belfry",
"belgian",
"belgique",
"belgium",
"belgrade",
"belief",
"believability",
"believer",
"believing",
"belisarius",
"belittling",
"belize",
"bell",
"belladonna",
"bellarmine",
"bellarmino",
"bellbird",
"bellboy",
"belle",
"bellerophon",
"bellflower",
"bellhop",
"bellicoseness",
"bellicosity",
"belligerence",
"belligerency",
"belligerent",
"belling",
"bellingham",
"bellini",
"bellis",
"bellman",
"belloc",
"bellow",
"bellower",
"bellowing",
"bellows",
"bellpull",
"bellwether",
"bellwort",
"belly",
"bellyache",
"bellyacher",
"bellyband",
"bellybutton",
"bellyful",
"belmont",
"belonging",
"belongings",
"belonidae",
"belorussia",
"belorussian",
"belostomatidae",
"beloved",
"belsen",
"belshazzar",
"belt",
"belting",
"beltway",
"beluga",
"belvedere",
"bema",
"bemidji",
"bemisia",
"bemusement",
"benadryl",
"bench",
"benchley",
"benchmark",
"bend",
"bendability",
"bender",
"bending",
"bendopa",
"bends",
"benedick",
"benedict",
"benedictine",
"benediction",
"benefaction",
"benefactor",
"benefactress",
"benefice",
"beneficence",
"beneficiary",
"beneficiation",
"benefit",
"benelux",
"benet",
"benevolence",
"bengal",
"bengali",
"benghazi",
"benignancy",
"benignity",
"benin",
"beninese",
"benison",
"benjamin",
"benne",
"bennet",
"bennett",
"bennettitaceae",
"bennettitales",
"bennettitis",
"benni",
"bennie",
"bennington",
"benniseed",
"benny",
"bent",
"bentham",
"benthos",
"benton",
"bentonite",
"bentwood",
"benweed",
"benzedrine",
"benzene",
"benzine",
"benzoate",
"benzocaine",
"benzodiazepine",
"benzofuran",
"benzoin",
"benzol",
"benzoquinone",
"benzyl",
"beograd",
"beowulf",
"bequest",
"berating",
"berber",
"berberidaceae",
"berberis",
"berbers",
"berceuse",
"bercy",
"bereaved",
"bereavement",
"beret",
"berg",
"bergall",
"bergamot",
"bergen",
"bergenia",
"bergman",
"bergson",
"beria",
"beriberi",
"bering",
"berit",
"berith",
"berk",
"berkeley",
"berkelium",
"berkshire",
"berkshires",
"berlage",
"berlin",
"berliner",
"berlioz",
"berm",
"bermuda",
"bermudan",
"bermudas",
"bermudian",
"bern",
"bernard",
"berne",
"bernhardt",
"bernini",
"bernoulli",
"bernstein",
"beroe",
"berra",
"berretta",
"berry",
"berserk",
"berserker",
"berteroa",
"berth",
"bertholletia",
"bertillon",
"bertolucci",
"berycomorphi",
"beryl",
"beryllium",
"berzelius",
"besieger",
"besieging",
"besom",
"bessel",
"bessemer",
"bessera",
"besseya",
"best",
"bestiality",
"bestiary",
"bestowal",
"bestower",
"bestowment",
"bestseller",
"beta",
"betaine",
"betatron",
"betel",
"betelgeuse",
"beth",
"bethe",
"bethel",
"bethlehem",
"bethune",
"betise",
"betrayal",
"betrayer",
"betrothal",
"betrothed",
"better",
"betterment",
"bettong",
"bettongia",
"bettor",
"betula",
"betulaceae",
"betweenbrain",
"bevatron",
"bevel",
"beverage",
"beveridge",
"bevin",
"bevy",
"bewilderment",
"bewitchery",
"bewitchment",
"bextra",
"bezant",
"bezel",
"bezique",
"bezzant",
"bhadon",
"bhadrapada",
"bhaga",
"bhagavadgita",
"bhakti",
"bhang",
"bharat",
"bhutan",
"bhutanese",
"bhutani",
"bialy",
"bialystoker",
"bias",
"bible",
"bibliographer",
"bibliography",
"bibliolatry",
"bibliomania",
"bibliophile",
"bibliopole",
"bibliopolist",
"bibliothec",
"bibliotheca",
"bibliotics",
"bibliotist",
"bibos",
"bicarbonate",
"bicentenary",
"bicentennial",
"biceps",
"bichloride",
"bichromate",
"bicker",
"bickering",
"bicorn",
"bicorne",
"bicuspid",
"bicycle",
"bicycler",
"bicycling",
"bicyclist",
"bida",
"bidder",
"bidding",
"biddy",
"bidens",
"bidet",
"biennial",
"bier",
"bierce",
"biff",
"bifocals",
"bifurcation",
"bigamist",
"bigamy",
"bigarade",
"bigeye",
"bigfoot",
"biggin",
"bighead",
"bigheartedness",
"bighorn",
"bight",
"bigness",
"bignonia",
"bignoniaceae",
"bignoniad",
"bigos",
"bigot",
"bigotry",
"bigram",
"bigwig",
"bihar",
"bihari",
"bijou",
"bike",
"biker",
"bikers",
"bikini",
"bilabial",
"bilateralism",
"bilaterality",
"bilberry",
"bilby",
"bile",
"bilestone",
"bilge",
"bilges",
"bilgewater",
"bilharzia",
"bilharziasis",
"bilimbi",
"bilingual",
"bilingualism",
"bilingualist",
"biliousness",
"bilirubin",
"bill",
"billabong",
"billboard",
"billet",
"billfish",
"billfold",
"billhook",
"billiards",
"billing",
"billings",
"billingsgate",
"billion",
"billionaire",
"billionth",
"billow",
"billy",
"billyo",
"billyoh",
"billystick",
"bilocation",
"biloxi",
"bilsted",
"biltong",
"bimbo",
"bimester",
"bimetal",
"bimetallism",
"bimetallist",
"bimillenary",
"bimillennium",
"bimli",
"bimonthly",
"binary",
"bind",
"binder",
"bindery",
"binding",
"bindweed",
"bine",
"binet",
"binful",
"binge",
"binger",
"binghamton",
"bingle",
"bingo",
"binnacle",
"binoculars",
"binomial",
"binturong",
"bioarm",
"bioassay",
"bioattack",
"biocatalyst",
"biochemist",
"biochemistry",
"biochip",
"bioclimatology",
"biodefence",
"biodefense",
"biodiversity",
"bioelectricity",
"bioengineering",
"bioethics",
"biofeedback",
"bioflavinoid",
"biogenesis",
"biogeny",
"biogeography",
"biographer",
"biography",
"biohazard",
"bioko",
"biologism",
"biologist",
"biology",
"bioluminescence",
"biomass",
"biome",
"biomedicine",
"biometrics",
"biometry",
"bionics",
"bionomics",
"biont",
"biophysicist",
"biophysics",
"biopiracy",
"biopsy",
"bioremediation",
"biosafety",
"bioscience",
"bioscope",
"biosphere",
"biostatistics",
"biosynthesis",
"biosystematics",
"biosystematy",
"biota",
"biotech",
"biotechnology",
"bioterrorism",
"biotin",
"biotite",
"biotype",
"bioweapon",
"biped",
"bipedalism",
"biplane",
"biprism",
"biquadrate",
"biquadratic",
"birch",
"birchbark",
"bird",
"birdbath",
"birdbrain",
"birdcage",
"birdcall",
"birder",
"birdfeeder",
"birdhouse",
"birdie",
"birdlime",
"birdnest",
"birdnesting",
"birdseed",
"birdsong",
"birefringence",
"biretta",
"biriani",
"birling",
"birmingham",
"biro",
"birr",
"birretta",
"birth",
"birthday",
"birthing",
"birthmark",
"birthplace",
"birthrate",
"birthright",
"birthroot",
"birthwort",
"biryani",
"bisayan",
"bisayas",
"biscuit",
"biscutella",
"bise",
"bisection",
"bisexual",
"bisexuality",
"bishkek",
"bishop",
"bishopric",
"bishopry",
"biskek",
"bismarck",
"bismark",
"bismuth",
"bison",
"bisque",
"bissau",
"bister",
"bistre",
"bistro",
"bitartrate",
"bitch",
"bitchery",
"bitchiness",
"bite",
"biteplate",
"biter",
"bitewing",
"bithynia",
"bitis",
"bitmap",
"bitok",
"bitstock",
"bitt",
"bittacidae",
"bitter",
"bittercress",
"bittern",
"bitterness",
"bitternut",
"bitterroot",
"bitters",
"bittersweet",
"bitterweed",
"bitterwood",
"bitthead",
"bitumastic",
"bitumen",
"bivalve",
"bivalvia",
"bivouac",
"bivouacking",
"biweekly",
"bizarreness",
"bize",
"bizet",
"blabber",
"blabbermouth",
"blaberus",
"black",
"blackball",
"blackbeard",
"blackbeetle",
"blackberry",
"blackbird",
"blackboard",
"blackbody",
"blackbuck",
"blackburn",
"blackcap",
"blackcock",
"blackdamp",
"blackening",
"blackface",
"blackfish",
"blackfly",
"blackfoot",
"blackfriar",
"blackguard",
"blackhead",
"blackheart",
"blacking",
"blackjack",
"blackleg",
"blacklist",
"blackmail",
"blackmailer",
"blackness",
"blackout",
"blackpoll",
"blackpool",
"blacksburg",
"blackseed",
"blackshirt",
"blacksmith",
"blacksnake",
"blacktail",
"blackthorn",
"blacktop",
"blacktopping",
"blackwash",
"blackwater",
"blackwood",
"bladder",
"bladdernose",
"bladderpod",
"bladderwort",
"bladderwrack",
"blade",
"blaeberry",
"blah",
"blahs",
"blain",
"blair",
"blake",
"blame",
"blamelessness",
"blameworthiness",
"blanc",
"blancmange",
"blandfordia",
"blandishment",
"blandness",
"blank",
"blanket",
"blankness",
"blanquillo",
"blantyre",
"blare",
"blarina",
"blaring",
"blarney",
"blasphemer",
"blasphemy",
"blast",
"blastema",
"blaster",
"blastocele",
"blastocladia",
"blastocladiales",
"blastocoel",
"blastocoele",
"blastocyst",
"blastocyte",
"blastocytoma",
"blastoderm",
"blastodiaceae",
"blastodisc",
"blastoff",
"blastogenesis",
"blastoma",
"blastomere",
"blastomyces",
"blastomycete",
"blastomycosis",
"blastopore",
"blastosphere",
"blastula",
"blatancy",
"blather",
"blatherskite",
"blatta",
"blattaria",
"blattella",
"blattidae",
"blattodea",
"blaxploitation",
"blaze",
"blazer",
"blazing",
"blazon",
"blazonry",
"bleach",
"bleacher",
"bleachers",
"bleakness",
"bleat",
"bleb",
"blechnaceae",
"blechnum",
"bleeder",
"bleeding",
"bleep",
"blemish",
"blend",
"blende",
"blender",
"blending",
"blenheim",
"blenniidae",
"blennioid",
"blennioidea",
"blennius",
"blenny",
"blepharism",
"blepharitis",
"blepharospasm",
"blephilia",
"bleriot",
"blessedness",
"blessing",
"blether",
"bletia",
"bletilla",
"bleu",
"blewits",
"blida",
"bligh",
"blighia",
"blight",
"blighter",
"blighty",
"blimp",
"blind",
"blinder",
"blindfold",
"blindness",
"blindworm",
"bling",
"blini",
"blink",
"blinker",
"blinking",
"blinks",
"blintz",
"blintze",
"bliny",
"blip",
"bliss",
"blissfulness",
"blissus",
"blister",
"blistering",
"blitheness",
"blitt",
"blitz",
"blitzkrieg",
"blitzstein",
"blixen",
"blizzard",
"bloat",
"bloater",
"blob",
"bloc",
"blocadren",
"bloch",
"block",
"blockade",
"blockage",
"blockbuster",
"blocker",
"blockhead",
"blockhouse",
"blocking",
"bloemfontein",
"blog",
"blogger",
"blok",
"bloke",
"blolly",
"blond",
"blonde",
"blondness",
"blood",
"bloodbath",
"bloodberry",
"bloodguilt",
"bloodhound",
"bloodiness",
"bloodleaf",
"bloodletting",
"bloodline",
"bloodlust",
"bloodmobile",
"bloodroot",
"bloodshed",
"bloodstain",
"bloodstock",
"bloodstone",
"bloodstream",
"bloodsucker",
"bloodworm",
"bloodwort",
"bloom",
"bloomer",
"bloomeria",
"bloomers",
"bloomfield",
"blooming",
"bloomington",
"bloomsbury",
"blooper",
"blossom",
"blossoming",
"blot",
"blotch",
"blotter",
"blouse",
"blow",
"blowback",
"blowball",
"blower",
"blowfish",
"blowfly",
"blowgun",
"blowhard",
"blowhole",
"blowing",
"blowjob",
"blowlamp",
"blowout",
"blowpipe",
"blowtorch",
"blowtube",
"blowup",
"blubber",
"blubberer",
"blucher",
"bludgeon",
"bludgeoner",
"blue",
"bluebeard",
"bluebell",
"blueberry",
"bluebill",
"bluebird",
"bluebonnet",
"bluebottle",
"bluecoat",
"bluefin",
"bluefish",
"bluegill",
"bluegrass",
"bluehead",
"blueing",
"bluejacket",
"blueness",
"bluenose",
"bluepoint",
"blueprint",
"blues",
"bluestem",
"bluestocking",
"bluestone",
"bluethroat",
"bluetick",
"bluetongue",
"blueweed",
"bluewing",
"bluff",
"bluffer",
"bluffness",
"bluing",
"blunder",
"blunderbuss",
"blunderer",
"bluntness",
"blur",
"blurb",
"blurriness",
"blush",
"blusher",
"bluster",
"blusterer",
"bmdo",
"bmus",
"boann",
"boar",
"board",
"boarder",
"boarding",
"boardinghouse",
"boardroom",
"boards",
"boardwalk",
"boarfish",
"boarhound",
"boast",
"boaster",
"boastfulness",
"boasting",
"boat",
"boatbill",
"boatbuilder",
"boater",
"boathouse",
"boating",
"boatload",
"boatman",
"boatmanship",
"boatswain",
"boatyard",
"bobber",
"bobbin",
"bobble",
"bobby",
"bobbysock",
"bobbysocks",
"bobbysoxer",
"bobcat",
"bobfloat",
"bobolink",
"bobsled",
"bobsledding",
"bobsleigh",
"bobtail",
"bobwhite",
"boccaccio",
"bocce",
"bocci",
"boccie",
"bocconia",
"boche",
"bock",
"boddhisatva",
"bodega",
"bodensee",
"bodhisattva",
"bodice",
"boding",
"bodkin",
"bodoni",
"body",
"bodybuilder",
"bodybuilding",
"bodyguard",
"bodywork",
"boehm",
"boehme",
"boehmenism",
"boehmeria",
"boell",
"boeotia",
"boer",
"boethius",
"boeuf",
"boffin",
"bogart",
"bogbean",
"bogey",
"bogeyman",
"bogie",
"bogmat",
"bogota",
"bogy",
"bohemia",
"bohemian",
"bohemianism",
"bohme",
"bohr",
"bohrium",
"boidae",
"boil",
"boiler",
"boilerplate",
"boilersuit",
"boiling",
"boise",
"boisterousness",
"bokkos",
"bokmaal",
"bokmal",
"bola",
"bolanci",
"bolbitis",
"bold",
"boldface",
"boldness",
"bole",
"bolero",
"boletaceae",
"bolete",
"boletellus",
"boletus",
"boleyn",
"bolide",
"bolingbroke",
"bolivar",
"bolivia",
"bolivian",
"boliviano",
"boll",
"bollard",
"bollock",
"bollworm",
"bollywood",
"bolo",
"bologna",
"bologram",
"bolograph",
"bolometer",
"boloney",
"bolshevik",
"bolshevism",
"bolshevist",
"bolshie",
"bolshy",
"bolster",
"bolt",
"bolti",
"boltonia",
"boltzmann",
"bolus",
"bolzano",
"bomarea",
"bomb",
"bombacaceae",
"bombard",
"bombardier",
"bombardment",
"bombardon",
"bombast",
"bombax",
"bombay",
"bombazine",
"bomber",
"bombie",
"bombilation",
"bombina",
"bombination",
"bombing",
"bomblet",
"bombproof",
"bombshell",
"bombsight",
"bombus",
"bombycid",
"bombycidae",
"bombycilla",
"bombycillidae",
"bombyliidae",
"bombyx",
"bonaire",
"bonanza",
"bonaparte",
"bonasa",
"bonavist",
"bonbon",
"bonce",
"bond",
"bondage",
"bondholder",
"bonding",
"bondmaid",
"bondman",
"bondsman",
"bondswoman",
"bonduc",
"bondwoman",
"bone",
"bonefish",
"bonehead",
"bonelet",
"bonemeal",
"boner",
"bones",
"boneset",
"bonesetter",
"boneshaker",
"bonete",
"bonfire",
"bong",
"bongo",
"bonheur",
"bonhoeffer",
"bonhomie",
"boniface",
"boniness",
"bonito",
"bonn",
"bonnet",
"bonnethead",
"bonney",
"bonobo",
"bonsai",
"bontemps",
"bonus",
"bonxie",
"bonyness",
"boob",
"booboisie",
"booby",
"boodle",
"booger",
"boogeyman",
"boogie",
"book",
"bookbinder",
"bookbindery",
"bookbinding",
"bookcase",
"bookclub",
"bookdealer",
"bookend",
"booker",
"bookfair",
"bookie",
"booking",
"bookishness",
"bookkeeper",
"bookkeeping",
"booklet",
"booklouse",
"booklover",
"bookmaker",
"bookman",
"bookmark",
"bookmarker",
"bookmobile",
"bookplate",
"bookseller",
"bookshelf",
"bookshop",
"bookstall",
"bookstore",
"bookworm",
"boole",
"boom",
"boomer",
"boomerang",
"boon",
"boondocks",
"boondoggle",
"boone",
"boor",
"boorishness",
"boost",
"booster",
"boot",
"bootblack",
"bootboys",
"bootee",
"bootes",
"booth",
"boothose",
"bootie",
"bootjack",
"bootlace",
"bootleg",
"bootlegger",
"bootlegging",
"bootlicker",
"bootmaker",
"bootstrap",
"booty",
"booyong",
"booze",
"boozer",
"boozing",
"bopeep",
"borage",
"boraginaceae",
"borago",
"borassus",
"borate",
"borax",
"bordeaux",
"bordelaise",
"bordello",
"border",
"borderer",
"borderland",
"borderline",
"bore",
"boreas",
"borecole",
"boredom",
"borer",
"borges",
"borgia",
"boring",
"boringness",
"born",
"bornean",
"borneo",
"bornite",
"borodin",
"borodino",
"boron",
"borosilicate",
"borough",
"borrelia",
"borrower",
"borrowing",
"borsch",
"borscht",
"borsh",
"borshch",
"borsht",
"borstal",
"bortsch",
"borzoi",
"bosc",
"bosch",
"bose",
"boselaphus",
"bosh",
"bosie",
"bosk",
"bosnia",
"bosom",
"boson",
"bosporus",
"boss",
"bossism",
"boston",
"bostonian",
"bosun",
"boswell",
"boswellia",
"bota",
"botanical",
"botanist",
"botany",
"botaurus",
"botch",
"botcher",
"botfly",
"bother",
"botheration",
"bothidae",
"bothrops",
"botox",
"botrychium",
"botswana",
"botticelli",
"bottle",
"bottlebrush",
"bottlecap",
"bottleful",
"bottleneck",
"bottlenose",
"bottler",
"bottom",
"bottomland",
"bottomlessness",
"botulin",
"botulinum",
"botulinus",
"botulism",
"botulismotoxin",
"bouchee",
"boucle",
"boudoir",
"bouffant",
"bouffe",
"bougainvillaea",
"bougainville",
"bougainvillea",
"bough",
"bouillabaisse",
"bouillon",
"boulder",
"boule",
"boulevard",
"boulevardier",
"boulez",
"boulle",
"bounce",
"bouncer",
"bounciness",
"bouncing",
"bound",
"boundary",
"boundedness",
"bounder",
"boundlessness",
"bounds",
"bounteousness",
"bountifulness",
"bounty",
"bouquet",
"bourbon",
"bourdon",
"bourgeois",
"bourgeoisie",
"bourgogne",
"bourguignon",
"bourn",
"bourne",
"bourse",
"bourtree",
"boustrophedon",
"bout",
"bouteloua",
"boutique",
"boutonniere",
"bouvines",
"bouyei",
"bovid",
"bovidae",
"bovinae",
"bovine",
"bovini",
"bovril",
"bowditch",
"bowdler",
"bowdlerisation",
"bowdleriser",
"bowdlerism",
"bowdlerization",
"bowdlerizer",
"bowel",
"bowels",
"bower",
"bowerbird",
"bowery",
"bowfin",
"bowhead",
"bowie",
"bowiea",
"bowing",
"bowknot",
"bowl",
"bowlder",
"bowleg",
"bowler",
"bowlful",
"bowline",
"bowling",
"bowls",
"bowman",
"bowsprit",
"bowstring",
"bowtie",
"boxberry",
"boxcar",
"boxcars",
"boxer",
"boxers",
"boxershorts",
"boxfish",
"boxful",
"boxing",
"boxthorn",
"boxwood",
"boycott",
"boyfriend",
"boyhood",
"boyishness",
"boykinia",
"boyle",
"boyne",
"boysenberry",
"bozeman",
"bozo",
"brace",
"bracelet",
"bracer",
"bracero",
"braces",
"brachiation",
"brachinus",
"brachiopod",
"brachiopoda",
"brachium",
"brachycephalic",
"brachycephalism",
"brachycephaly",
"brachychiton",
"brachycome",
"brachydactylia",
"brachydactyly",
"brachystegia",
"brachyura",
"brachyuran",
"bracing",
"bracken",
"bracket",
"brackishness",
"bract",
"bracteole",
"bractlet",
"brad",
"bradawl",
"bradbury",
"bradford",
"bradley",
"bradstreet",
"brady",
"bradycardia",
"bradypodidae",
"bradypus",
"brae",
"brag",
"braga",
"brage",
"bragg",
"braggadocio",
"braggart",
"bragger",
"bragging",
"bragi",
"brahe",
"brahma",
"brahman",
"brahmana",
"brahmanism",
"brahmaputra",
"brahmi",
"brahmin",
"brahminism",
"brahms",
"brahui",
"braid",
"braiding",
"brail",
"braille",
"brain",
"braincase",
"brainchild",
"brainiac",
"brainpan",
"brainpower",
"brainstem",
"brainstorm",
"brainstorming",
"brainwashing",
"brainwave",
"brainworker",
"braising",
"brake",
"brakeman",
"brakes",
"brama",
"bramante",
"bramble",
"brambling",
"bramidae",
"bran",
"branch",
"branchia",
"branching",
"branchiobdella",
"branchiopod",
"branchiopoda",
"branchiopodan",
"branchiura",
"branchlet",
"brancusi",
"brand",
"brandenburg",
"branding",
"brandish",
"brandt",
"brandy",
"brandyball",
"brandysnap",
"brant",
"branta",
"braque",
"brasenia",
"brashness",
"brasier",
"brasil",
"brasilia",
"brasov",
"brass",
"brassard",
"brassavola",
"brasserie",
"brassia",
"brassica",
"brassicaceae",
"brassie",
"brassiere",
"brat",
"bratislava",
"brattice",
"brattleboro",
"bratwurst",
"braun",
"braunschweig",
"bravado",
"brave",
"braveness",
"bravery",
"bravo",
"bravura",
"brawl",
"brawler",
"brawn",
"brawniness",
"bray",
"brazenness",
"brazier",
"brazil",
"brazilian",
"brazilwood",
"brazos",
"brazzaville",
"breach",
"bread",
"breadbasket",
"breadboard",
"breadbox",
"breadcrumb",
"breadfruit",
"breadline",
"breadroot",
"breadstick",
"breadstuff",
"breadth",
"breadwinner",
"break",
"breakability",
"breakable",
"breakableness",
"breakage",
"breakaway",
"breakax",
"breakaxe",
"breakdown",
"breaker",
"breakers",
"breakfast",
"breaking",
"breakout",
"breakstone",
"breakthrough",
"breakup",
"breakwater",
"bream",
"breast",
"breastbone",
"breastpin",
"breastplate",
"breaststroke",
"breaststroker",
"breastwork",
"breath",
"breathalyser",
"breathalyzer",
"breather",
"breathing",
"breathlessness",
"breccia",
"brecht",
"breech",
"breechblock",
"breechcloth",
"breechclout",
"breeches",
"breechloader",
"breed",
"breeder",
"breeding",
"breeze",
"breeziness",
"bregma",
"breiz",
"bremen",
"bremerhaven",
"bren",
"brent",
"brescia",
"breslau",
"brest",
"bretagne",
"brethren",
"breton",
"breuer",
"breughel",
"breve",
"brevet",
"breviary",
"brevibloc",
"brevicipitidae",
"brevity",
"brevoortia",
"brew",
"brewage",
"brewer",
"brewery",
"brewing",
"brewpub",
"brezhnev",
"briar",
"briard",
"briarroot",
"briarwood",
"bribe",
"briber",
"bribery",
"brick",
"brickbat",
"brickellia",
"brickfield",
"brickkiln",
"bricklayer",
"bricklaying",
"brickwork",
"brickyard",
"bricolage",
"bricole",
"bridal",
"bride",
"bridecake",
"bridegroom",
"bridesmaid",
"bridge",
"bridgehead",
"bridgeport",
"bridges",
"bridget",
"bridgetown",
"bridgework",
"bridle",
"bridoon",
"brie",
"brief",
"briefcase",
"briefing",
"briefness",
"briefs",
"brier",
"brierpatch",
"brierwood",
"brig",
"brigade",
"brigadier",
"brigand",
"brigandine",
"brigantine",
"brightness",
"brighton",
"brigid",
"brigit",
"brihaspati",
"brill",
"brilliance",
"brilliancy",
"brilliantine",
"brim",
"brimstone",
"brindisi",
"brine",
"bringing",
"brininess",
"brinjal",
"brink",
"brinkmanship",
"brinton",
"briny",
"brio",
"brioche",
"briony",
"brioschi",
"briquet",
"briquette",
"bris",
"brisance",
"brisbane",
"brisket",
"briskness",
"brisling",
"briss",
"bristle",
"bristlegrass",
"bristletail",
"bristliness",
"bristol",
"brit",
"britain",
"britches",
"brith",
"briticism",
"british",
"britisher",
"britishism",
"briton",
"brits",
"britt",
"brittanic",
"brittany",
"britten",
"brittle",
"brittlebush",
"brittleness",
"brno",
"broach",
"broad",
"broadax",
"broadaxe",
"broadbill",
"broadcast",
"broadcaster",
"broadcasting",
"broadcloth",
"broadening",
"broadloom",
"broadness",
"broadsheet",
"broadside",
"broadsword",
"broadtail",
"broadway",
"brobdingnag",
"broca",
"brocade",
"brocadopa",
"broccoli",
"brochette",
"brochure",
"brocket",
"brockhouse",
"brodiaea",
"brogan",
"broglie",
"brogue",
"broil",
"broiler",
"broiling",
"broker",
"brokerage",
"brolly",
"bromberg",
"brome",
"bromegrass",
"bromelia",
"bromeliaceae",
"bromeosin",
"bromide",
"bromine",
"bromoform",
"bromus",
"bronc",
"bronchiole",
"bronchiolitis",
"bronchitis",
"broncho",
"bronchodilator",
"bronchoscope",
"bronchospasm",
"bronchus",
"bronco",
"broncobuster",
"bronte",
"brontosaur",
"brontosaurus",
"bronx",
"bronze",
"brooch",
"brood",
"brooder",
"brooding",
"broodmare",
"broody",
"brook",
"brooke",
"brooklet",
"brooklime",
"brooklyn",
"brooks",
"brookweed",
"broom",
"broomcorn",
"broomstick",
"broomweed",
"brosmius",
"broth",
"brothel",
"brother",
"brotherhood",
"brotula",
"brotulidae",
"brougham",
"brouhaha",
"broussonetia",
"brow",
"browallia",
"brown",
"browne",
"brownie",
"browning",
"brownness",
"brownout",
"brownshirt",
"brownstone",
"brownsville",
"browntail",
"browse",
"browser",
"browsing",
"bruce",
"brucella",
"brucellosis",
"bruch",
"bruchidae",
"bruchus",
"brucine",
"bruckenthalia",
"bruckner",
"bruegel",
"brueghel",
"bruges",
"brugmansia",
"bruin",
"bruise",
"bruiser",
"brule",
"brumaire",
"brummagem",
"brummell",
"brummie",
"brummy",
"brunanburh",
"brunch",
"brunei",
"bruneian",
"brunelleschi",
"brunet",
"brunette",
"brunfelsia",
"brunhild",
"brunn",
"brunnhilde",
"bruno",
"brunswick",
"brunt",
"brusa",
"brush",
"brushing",
"brushup",
"brushwood",
"brushwork",
"brusqueness",
"brussels",
"brutalisation",
"brutality",
"brutalization",
"brute",
"brutus",
"bruxelles",
"bruxism",
"brya",
"bryaceae",
"bryales",
"bryan",
"bryanthus",
"brynhild",
"bryony",
"bryophyta",
"bryophyte",
"bryopsida",
"bryozoa",
"bryozoan",
"brythonic",
"bryum",
"bsarch",
"bubalus",
"bubble",
"bubblejet",
"bubbler",
"bubbliness",
"bubbly",
"buber",
"bubo",
"bubulcus",
"buccaneer",
"buccaneering",
"buccinidae",
"bucconidae",
"buccula",
"bucephala",
"buceros",
"bucerotidae",
"buchanan",
"bucharest",
"bucharesti",
"buchenwald",
"buchloe",
"buchner",
"buck",
"buckaroo",
"buckbean",
"buckboard",
"buckeroo",
"bucket",
"bucketful",
"buckeye",
"buckle",
"buckler",
"buckleya",
"buckram",
"bucksaw",
"buckshot",
"buckskin",
"buckskins",
"buckthorn",
"bucktooth",
"buckwheat",
"buckyball",
"bucolic",
"bucuresti",
"budapest",
"buddha",
"buddhism",
"buddhist",
"budding",
"buddleia",
"buddy",
"budge",
"budgereegah",
"budgerigar",
"budgerygah",
"budget",
"budgie",
"budorcas",
"buff",
"buffalo",
"buffalofish",
"buffer",
"bufferin",
"buffet",
"buffeting",
"bufflehead",
"buffoon",
"buffoonery",
"bufo",
"bufonidae",
"bugaboo",
"buganda",
"bugbane",
"bugbear",
"bugger",
"buggery",
"bugginess",
"buggy",
"bugle",
"bugler",
"bugleweed",
"bugloss",
"bugologist",
"bugology",
"buhl",
"build",
"builder",
"building",
"buildup",
"bujumbura",
"bukharin",
"bulawayo",
"bulb",
"bulbil",
"bulblet",
"bulbul",
"bulgaria",
"bulgarian",
"bulge",
"bulghur",
"bulginess",
"bulgur",
"bulimarexia",
"bulimia",
"bulimic",
"bulk",
"bulkhead",
"bulkiness",
"bull",
"bulla",
"bullace",
"bullbat",
"bullbrier",
"bulldog",
"bulldozer",
"bullet",
"bullethead",
"bulletin",
"bullfight",
"bullfighter",
"bullfighting",
"bullfinch",
"bullfrog",
"bullhead",
"bullheadedness",
"bullhorn",
"bullion",
"bullnose",
"bullock",
"bullpen",
"bullring",
"bullrush",
"bullshit",
"bullshot",
"bullterrier",
"bully",
"bullyboy",
"bullying",
"bulnesia",
"bulrush",
"bultmann",
"bulwark",
"bumblebee",
"bumbler",
"bumboat",
"bumelia",
"bumf",
"bummer",
"bump",
"bumper",
"bumph",
"bumpiness",
"bumpkin",
"bumptiousness",
"buna",
"bunce",
"bunch",
"bunchberry",
"bunche",
"bunchgrass",
"bunco",
"buncombe",
"bundesbank",
"bundle",
"bundling",
"bunfight",
"bung",
"bungalow",
"bungarus",
"bungee",
"bunghole",
"bungle",
"bungler",
"bunion",
"bunk",
"bunker",
"bunkmate",
"bunko",
"bunkum",
"bunny",
"buns",
"bunsen",
"bunt",
"buntal",
"bunter",
"bunting",
"bunuel",
"bunyan",
"bunyaviridae",
"bunyavirus",
"buoy",
"buoyancy",
"buphthalmum",
"bura",
"burbage",
"burbank",
"burberry",
"burbot",
"burden",
"burdensomeness",
"burdock",
"bureau",
"bureaucracy",
"bureaucrat",
"bureaucratism",
"buret",
"burette",
"burg",
"burger",
"burgess",
"burgh",
"burgher",
"burglar",
"burglary",
"burgomaster",
"burgoo",
"burgoyne",
"burgrass",
"burgrave",
"burgundy",
"burhinidae",
"burhinus",
"burial",
"burin",
"burk",
"burka",
"burke",
"burl",
"burlap",
"burlesque",
"burlington",
"burma",
"burmannia",
"burmanniaceae",
"burmeisteria",
"burmese",
"burn",
"burnability",
"burner",
"burnett",
"burnham",
"burning",
"burnish",
"burnoose",
"burnous",
"burnouse",
"burns",
"burnside",
"burnup",
"burp",
"burping",
"burqa",
"burr",
"burrawong",
"burrfish",
"burrito",
"burro",
"burroughs",
"burrow",
"bursa",
"bursar",
"bursary",
"bursera",
"burseraceae",
"bursitis",
"burst",
"burster",
"burt",
"burthen",
"burton",
"burundi",
"burundian",
"burunduki",
"burying",
"busbar",
"busboy",
"busby",
"bush",
"bushbaby",
"bushbuck",
"bushel",
"bushido",
"bushing",
"bushman",
"bushnell",
"bushtit",
"bushwhacker",
"business",
"businessman",
"businessmen",
"businesspeople",
"businessperson",
"businesswoman",
"busker",
"buskin",
"busload",
"busman",
"buspar",
"buspirone",
"buss",
"bust",
"bustard",
"buster",
"bustier",
"bustle",
"busybody",
"busyness",
"busywork",
"butacaine",
"butadiene",
"butane",
"butanol",
"butanone",
"butat",
"butazolidin",
"butch",
"butcher",
"butcherbird",
"butchering",
"butchery",
"butea",
"butene",
"buteo",
"buteonine",
"butler",
"butt",
"butte",
"butter",
"butterball",
"butterbean",
"butterbur",
"buttercrunch",
"buttercup",
"butterfat",
"butterfield",
"butterfingers",
"butterfish",
"butterflower",
"butterfly",
"butterflyfish",
"buttermilk",
"butternut",
"butterscotch",
"butterweed",
"butterwort",
"buttery",
"buttinsky",
"buttock",
"buttocks",
"button",
"buttonhole",
"buttonhook",
"buttonwood",
"buttress",
"buttressing",
"butty",
"butut",
"butyl",
"butylene",
"butyrin",
"buxaceae",
"buxomness",
"buxus",
"buyback",
"buyer",
"buyi",
"buying",
"buyout",
"buzz",
"buzzard",
"buzzer",
"buzzword",
"byblos",
"bycatch",
"bydgoszcz",
"byelarus",
"byelorussia",
"byelorussian",
"bygone",
"bylaw",
"byname",
"bypass",
"bypath",
"byplay",
"byproduct",
"byrd",
"byre",
"byrnie",
"byroad",
"byron",
"byssus",
"bystander",
"byte",
"byway",
"byword",
"byzant",
"byzantine",
"byzantinism",
"byzantium",
"caaba",
"cabal",
"cabala",
"cabalism",
"cabalist",
"cabana",
"cabaret",
"cabasset",
"cabassous",
"cabbage",
"cabbageworm",
"cabbala",
"cabbalah",
"cabby",
"cabdriver",
"cabell",
"caber",
"cabernet",
"cabg",
"cabin",
"cabinet",
"cabinetmaker",
"cabinetmaking",
"cabinetry",
"cabinetwork",
"cable",
"cablegram",
"cabman",
"cabochon",
"cabomba",
"cabombaceae",
"caboodle",
"caboose",
"cabot",
"cabotage",
"cabriolet",
"cabstand",
"cacajao",
"cacalia",
"cacao",
"cacatua",
"cachalot",
"cache",
"cachet",
"cachexia",
"cachexy",
"cachi",
"cachinnation",
"cachou",
"cacicus",
"cacique",
"cackle",
"cackler",
"cacodaemon",
"cacodemon",
"cacodyl",
"cacoethes",
"cacogenesis",
"cacogenics",
"cacography",
"cacomistle",
"cacomixle",
"cacophony",
"cactaceae",
"cactus",
"cadaster",
"cadastre",
"cadaver",
"cadaverine",
"caddie",
"caddisworm",
"caddo",
"caddoan",
"caddy",
"cadence",
"cadency",
"cadenza",
"cadet",
"cadetship",
"cadger",
"cadiz",
"cadmium",
"cadmus",
"cadra",
"cadre",
"caduceus",
"caeciliadae",
"caecilian",
"caeciliidae",
"caecum",
"caelum",
"caenogenesis",
"caenolestes",
"caenolestidae",
"caesalpinia",
"caesalpiniaceae",
"caesar",
"caesarea",
"caesarean",
"caesarian",
"caesarism",
"caesaropapism",
"caesium",
"caesura",
"cafe",
"cafeteria",
"caff",
"caffein",
"caffeine",
"caffeinism",
"caffer",
"caffre",
"caftan",
"cage",
"cager",
"cagliostro",
"cagney",
"cagoule",
"cahita",
"cahoot",
"caiman",
"caimitillo",
"caimito",
"cain",
"cainogenesis",
"cairene",
"cairina",
"cairn",
"cairngorm",
"cairo",
"caisson",
"caitiff",
"caitra",
"cajanus",
"cajolery",
"cajun",
"cakchiquel",
"cake",
"cakehole",
"cakewalk",
"cakile",
"calaba",
"calabash",
"calabazilla",
"calabria",
"calabura",
"caladenia",
"caladium",
"calais",
"calamagrostis",
"calamari",
"calamary",
"calamine",
"calamint",
"calamintha",
"calamity",
"calamus",
"calan",
"calandrinia",
"calanthe",
"calapooya",
"calapuya",
"calash",
"calcaneus",
"calcedony",
"calceolaria",
"calceus",
"calciferol",
"calcification",
"calcimine",
"calcination",
"calcite",
"calcitonin",
"calcium",
"calculation",
"calculator",
"calculus",
"calcutta",
"calder",
"caldera",
"calderon",
"caldron",
"caldwell",
"calean",
"caleche",
"caledonia",
"calefaction",
"calendar",
"calender",
"calendula",
"calf",
"calfskin",
"calgary",
"cali",
"caliber",
"calibration",
"calibre",
"caliche",
"calico",
"caliculus",
"calidris",
"calif",
"california",
"californian",
"californium",
"caligula",
"caliper",
"caliph",
"caliphate",
"calisaya",
"calisthenics",
"calk",
"calkin",
"call",
"calla",
"callas",
"callathump",
"callback",
"caller",
"calliandra",
"callicebus",
"calligrapher",
"calligraphist",
"calligraphy",
"callimorpha",
"callinectes",
"calling",
"callionymidae",
"calliope",
"calliophis",
"calliopsis",
"calliper",
"calliphora",
"calliphoridae",
"callirhoe",
"callisaurus",
"callistephus",
"callisthenics",
"callisto",
"callithricidae",
"callithrix",
"callithump",
"callitrichaceae",
"callitriche",
"callitris",
"callophis",
"callorhinus",
"callosectomy",
"callosity",
"callosotomy",
"callousness",
"callowness",
"calluna",
"callus",
"calm",
"calming",
"calmness",
"calocarpum",
"calocedrus",
"calochortus",
"calomel",
"caloocan",
"caloosahatchee",
"calophyllum",
"calopogon",
"calorie",
"calorimeter",
"calorimetry",
"calosoma",
"calostomataceae",
"calpac",
"calpack",
"calpe",
"calque",
"caltha",
"caltrop",
"calumet",
"calumniation",
"calumny",
"calvados",
"calvaria",
"calvary",
"calvatia",
"calvin",
"calving",
"calvinism",
"calvinist",
"calvino",
"calx",
"calycanthaceae",
"calycanthus",
"calycle",
"calycophyllum",
"calyculus",
"calypso",
"calypter",
"calyptra",
"calystegia",
"calyx",
"camachile",
"camail",
"camaraderie",
"camarilla",
"camas",
"camash",
"camass",
"camassia",
"cambarus",
"camber",
"cambium",
"cambodia",
"cambodian",
"cambria",
"cambrian",
"cambric",
"cambridge",
"camcorder",
"camden",
"camel",
"camelhair",
"camelia",
"camelidae",
"camelina",
"camellia",
"camelopard",
"camelot",
"camelpox",
"camelus",
"camembert",
"cameo",
"camera",
"cameraman",
"cameroon",
"cameroonian",
"cameroun",
"camion",
"camise",
"camisole",
"camlan",
"camlet",
"camo",
"camomile",
"camorra",
"camosh",
"camouflage",
"camp",
"campaign",
"campaigner",
"campaigning",
"campana",
"campania",
"campanile",
"campanula",
"campanulaceae",
"campanulales",
"campbell",
"campeachy",
"campeche",
"campephilus",
"camper",
"campfire",
"campground",
"camphor",
"camphorweed",
"camping",
"campion",
"campmate",
"campong",
"camponotus",
"campsite",
"campstool",
"camptosorus",
"campus",
"campyloneurum",
"campylorhynchus",
"camshaft",
"camus",
"camwood",
"canaan",
"canaanite",
"canaanitic",
"canachites",
"canada",
"canadian",
"canafistola",
"canafistula",
"canal",
"canaliculus",
"canalisation",
"canalization",
"cananga",
"canangium",
"canape",
"canara",
"canard",
"canarese",
"canaries",
"canary",
"canasta",
"canavalia",
"canavanine",
"canberra",
"cancan",
"cancel",
"cancellation",
"cancer",
"cancerweed",
"cancridae",
"cancroid",
"cancun",
"candela",
"candelabra",
"candelabrum",
"candelilla",
"candida",
"candidacy",
"candidate",
"candidature",
"candidiasis",
"candidness",
"candle",
"candleberry",
"candlelight",
"candlemaker",
"candlemas",
"candlenut",
"candlepin",
"candlepins",
"candlepower",
"candlesnuffer",
"candlestick",
"candlewick",
"candlewood",
"candor",
"candour",
"candy",
"candyfloss",
"candymaker",
"candytuft",
"candyweed",
"cane",
"canebrake",
"canecutter",
"canella",
"canellaceae",
"canetti",
"canfield",
"canful",
"cangue",
"canicula",
"canicule",
"canid",
"canidae",
"canine",
"caning",
"canis",
"canistel",
"canister",
"canker",
"cankerweed",
"cankerworm",
"canna",
"cannabidaceae",
"cannabin",
"cannabis",
"cannaceae",
"cannae",
"cannelloni",
"cannery",
"cannes",
"cannibal",
"cannibalism",
"cannikin",
"cannister",
"cannon",
"cannonade",
"cannonball",
"cannoneer",
"cannula",
"cannulation",
"cannulisation",
"cannulization",
"canoe",
"canoeist",
"canola",
"canon",
"canonisation",
"canonist",
"canonization",
"canopus",
"canopy",
"cant",
"cantabrigian",
"cantala",
"cantaloup",
"cantaloupe",
"cantata",
"canteen",
"canter",
"canterbury",
"cantharellus",
"canthus",
"canticle",
"canticles",
"cantilever",
"cantillation",
"cantle",
"canto",
"canton",
"cantonese",
"cantonment",
"cantor",
"canuck",
"canulation",
"canulisation",
"canulization",
"canute",
"canvas",
"canvasback",
"canvass",
"canvasser",
"canvassing",
"canyon",
"canyonside",
"caoutchouc",
"capability",
"capableness",
"capaciousness",
"capacitance",
"capacitor",
"capacity",
"caparison",
"cape",
"capek",
"capelan",
"capelin",
"capella",
"caper",
"capercaillie",
"capercailzie",
"capet",
"capetian",
"capeweed",
"capful",
"capibara",
"capillarity",
"capillary",
"capital",
"capitalisation",
"capitalism",
"capitalist",
"capitalization",
"capitate",
"capitation",
"capitol",
"capitonidae",
"capitulation",
"capitulum",
"capiz",
"caplin",
"capo",
"capon",
"capone",
"caporetto",
"capote",
"capoten",
"cappadocia",
"capparidaceae",
"capparis",
"cappelletti",
"cappuccino",
"capra",
"caprella",
"capreolus",
"capri",
"capriccio",
"caprice",
"capriciousness",
"capricorn",
"capricornis",
"capricornus",
"caprifig",
"caprifoliaceae",
"caprimulgid",
"caprimulgidae",
"caprimulgus",
"capriole",
"caproidae",
"capromyidae",
"capros",
"capsaicin",
"capsella",
"capsicum",
"capsid",
"capsidae",
"capsizing",
"capstan",
"capstone",
"capsule",
"captain",
"captaincy",
"captainship",
"caption",
"captivation",
"captive",
"captivity",
"captopril",
"captor",
"capture",
"capturer",
"capuchin",
"capulin",
"caput",
"capybara",
"carabao",
"carabidae",
"carabineer",
"carabiner",
"carabinier",
"caracal",
"caracara",
"caracas",
"carack",
"caracolito",
"caracul",
"carafate",
"carafe",
"caragana",
"carageen",
"carambola",
"caramel",
"carancha",
"caranda",
"caranday",
"carangid",
"carangidae",
"caranx",
"carapace",
"carapidae",
"carassius",
"carat",
"caravaggio",
"caravan",
"caravanning",
"caravansary",
"caravanserai",
"caraway",
"carbamate",
"carbamide",
"carbide",
"carbine",
"carbineer",
"carbohydrate",
"carboloy",
"carbomycin",
"carbon",
"carbonado",
"carbonara",
"carbonate",
"carbonation",
"carbondale",
"carboniferous",
"carbonisation",
"carbonization",
"carbonyl",
"carborundum",
"carboxyl",
"carboy",
"carbuncle",
"carburetor",
"carburettor",
"carcajou",
"carcase",
"carcass",
"carcharhinidae",
"carcharhinus",
"carcharias",
"carchariidae",
"carcharodon",
"carcinogen",
"carcinoid",
"carcinoma",
"carcinosarcoma",
"card",
"cardamine",
"cardamom",
"cardamon",
"cardamum",
"cardboard",
"cardcase",
"cardcastle",
"cardholder",
"cardhouse",
"cardia",
"cardiff",
"cardigan",
"cardiidae",
"cardinal",
"cardinalate",
"cardinalfish",
"cardinality",
"cardinalship",
"cardiogram",
"cardiograph",
"cardiography",
"cardioid",
"cardiologist",
"cardiology",
"cardiomegaly",
"cardiomyopathy",
"cardiopathy",
"cardiospasm",
"cardiospermum",
"carditis",
"cardium",
"cardizem",
"cardoon",
"cardroom",
"cards",
"cardsharp",
"cardsharper",
"carducci",
"carduelinae",
"carduelis",
"cardura",
"carduus",
"care",
"careen",
"career",
"careerism",
"careerist",
"carefreeness",
"carefulness",
"caregiver",
"carelessness",
"carelian",
"caress",
"caressing",
"caret",
"caretaker",
"caretta",
"carew",
"carex",
"carfare",
"carful",
"cargo",
"carhop",
"cariama",
"cariamidae",
"carib",
"caribbean",
"caribe",
"caribees",
"caribou",
"carica",
"caricaceae",
"caricature",
"caricaturist",
"caries",
"carillon",
"carillonneur",
"carina",
"carinate",
"caring",
"carioca",
"carissa",
"carjacking",
"carlina",
"carload",
"carlos",
"carlovingian",
"carlsbad",
"carlyle",
"carmaker",
"carmelite",
"carmichael",
"carminative",
"carmine",
"carnage",
"carnality",
"carnallite",
"carnation",
"carnauba",
"carnegie",
"carnegiea",
"carnelian",
"carnival",
"carnivora",
"carnivore",
"carnosaur",
"carnosaura",
"carnot",
"carnotite",
"carob",
"caroche",
"carol",
"caroler",
"carolina",
"carolinas",
"caroling",
"carolingian",
"carolinian",
"caroller",
"carolus",
"carom",
"carotene",
"carotenemia",
"carotenoid",
"carothers",
"carotin",
"carousal",
"carouse",
"carousel",
"carouser",
"carp",
"carpal",
"carpathians",
"carpel",
"carpentaria",
"carpenter",
"carpenteria",
"carpentry",
"carper",
"carpet",
"carpetbag",
"carpetbagger",
"carpeting",
"carpetweed",
"carphophis",
"carpinaceae",
"carping",
"carpinus",
"carpobrotus",
"carpocapsa",
"carpodacus",
"carpophore",
"carport",
"carpospore",
"carpus",
"carrack",
"carrageen",
"carrageenan",
"carrageenin",
"carragheen",
"carrefour",
"carrel",
"carrell",
"carrere",
"carriage",
"carriageway",
"carrier",
"carrion",
"carrizo",
"carroll",
"carrot",
"carrottop",
"carrousel",
"carry",
"carryall",
"carrycot",
"carson",
"cart",
"cartage",
"cartagena",
"carte",
"cartel",
"carter",
"cartesian",
"carthage",
"carthaginian",
"carthamus",
"carthorse",
"carthusian",
"cartier",
"cartilage",
"carting",
"cartload",
"cartographer",
"cartography",
"carton",
"cartonful",
"cartoon",
"cartoonist",
"cartouch",
"cartouche",
"cartridge",
"cartroad",
"cartwheel",
"cartwright",
"carum",
"caruncle",
"caruncula",
"caruso",
"carvedilol",
"carver",
"carving",
"carya",
"caryatid",
"caryocar",
"caryocaraceae",
"caryophyllaceae",
"caryophyllales",
"caryophyllidae",
"caryopsis",
"caryota",
"casaba",
"casablanca",
"casals",
"casanova",
"casava",
"casbah",
"cascabel",
"cascade",
"cascades",
"cascara",
"cascarilla",
"case",
"casebook",
"caseful",
"casein",
"casement",
"casern",
"casework",
"caseworker",
"caseworm",
"cash",
"cashbox",
"cashcard",
"cashew",
"cashier",
"cashmere",
"casing",
"casino",
"cask",
"casket",
"caskful",
"casmerodius",
"caspar",
"caspase",
"casper",
"caspian",
"casque",
"casquet",
"casquetel",
"cassandra",
"cassareep",
"cassava",
"casserole",
"cassette",
"cassia",
"cassie",
"cassino",
"cassiope",
"cassiopeia",
"cassirer",
"cassiri",
"cassite",
"cassiterite",
"cassius",
"cassock",
"cassowary",
"cast",
"castanea",
"castanets",
"castanopsis",
"castanospermum",
"castaway",
"caste",
"caster",
"castigation",
"castile",
"castilian",
"castilla",
"castilleia",
"castilleja",
"castillian",
"casting",
"castle",
"castling",
"castor",
"castoridae",
"castoroides",
"castrate",
"castration",
"castrato",
"castries",
"castro",
"castroism",
"casualness",
"casualty",
"casuaridae",
"casuariiformes",
"casuarina",
"casuarinaceae",
"casuarinales",
"casuarius",
"casuist",
"casuistry",
"catabiosis",
"catabolism",
"catacala",
"catachresis",
"cataclysm",
"catacomb",
"catafalque",
"cataflam",
"catalan",
"catalase",
"catalectic",
"catalepsy",
"cataleptic",
"catalexis",
"catalog",
"cataloger",
"catalogue",
"cataloguer",
"catalonia",
"catalpa",
"catalufa",
"catalysis",
"catalyst",
"catamaran",
"catamenia",
"catamite",
"catamount",
"catamountain",
"catananche",
"cataphasia",
"cataphatism",
"cataphoresis",
"cataphract",
"cataphyll",
"cataplasia",
"cataplasm",
"catapres",
"catapult",
"cataract",
"catarrh",
"catarrhine",
"catasetum",
"catastrophe",
"catatonia",
"catawba",
"catbird",
"catboat",
"catbrier",
"catcall",
"catch",
"catchall",
"catcher",
"catchfly",
"catching",
"catchment",
"catchphrase",
"catchweed",
"catchword",
"catclaw",
"catechesis",
"catechin",
"catechism",
"catechist",
"catecholamine",
"catechu",
"catechumen",
"categorem",
"categoreme",
"categorisation",
"categorization",
"category",
"catena",
"catenary",
"caterer",
"catering",
"caterpillar",
"caterwaul",
"catfish",
"catgut",
"catha",
"catharacta",
"catharanthus",
"cathari",
"catharism",
"cathars",
"catharsis",
"cathartes",
"cathartic",
"cathartid",
"cathartidae",
"cathay",
"cathaya",
"cathedra",
"cathedral",
"cather",
"catherine",
"catheter",
"catheterisation",
"catheterization",
"cathexis",
"cathode",
"catholic",
"catholicism",
"catholicity",
"catholicon",
"catholicos",
"cathouse",
"cation",
"catkin",
"catling",
"catmint",
"catnap",
"catnip",
"catoptrics",
"catoptrophorus",
"catostomid",
"catostomidae",
"catostomus",
"catskills",
"catsup",
"cattail",
"cattalo",
"cattell",
"cattie",
"cattiness",
"cattle",
"cattleman",
"cattleship",
"cattleya",
"catty",
"catullus",
"catwalk",
"caucasia",
"caucasian",
"caucasus",
"caucus",
"cauda",
"caudata",
"caudate",
"caudex",
"caul",
"cauldron",
"cauliflower",
"caulk",
"caulking",
"caulophyllum",
"causa",
"causalgia",
"causality",
"causation",
"cause",
"causerie",
"causeway",
"causing",
"caustic",
"cauterant",
"cauterisation",
"cauterization",
"cautery",
"caution",
"cautious",
"cautiousness",
"cavalcade",
"cavalier",
"cavalla",
"cavalry",
"cavalryman",
"cave",
"caveat",
"cavell",
"caveman",
"cavendish",
"cavern",
"cavetto",
"cavia",
"caviar",
"caviare",
"caviidae",
"cavil",
"caviler",
"caviller",
"cavity",
"cavum",
"cavy",
"caxton",
"cayenne",
"cayman",
"cayuga",
"cayuse",
"cazique",
"ccrc",
"cdna",
"cease",
"ceaselessness",
"cebidae",
"cebu",
"cebuan",
"cebuano",
"cebuella",
"cebus",
"cecidomyidae",
"cecity",
"cecropia",
"cecropiaceae",
"cecum",
"cedar",
"cedarbird",
"cedarwood",
"cedi",
"cedilla",
"ceding",
"cedrela",
"cedrus",
"cefadroxil",
"cefobid",
"cefoperazone",
"cefotaxime",
"ceftazidime",
"ceftin",
"ceftriaxone",
"cefuroxime",
"ceiba",
"ceibo",
"ceilidh",
"ceiling",
"celandine",
"celastraceae",
"celastrus",
"celebes",
"celebrant",
"celebrater",
"celebration",
"celebrator",
"celebrex",
"celebrity",
"celecoxib",
"celeriac",
"celerity",
"celery",
"celesta",
"celestite",
"celibacy",
"celibate",
"celiocentesis",
"celioma",
"celioscopy",
"cell",
"cellar",
"cellarage",
"cellaret",
"cellblock",
"cellini",
"cellist",
"cello",
"cellophane",
"cellphone",
"cellularity",
"cellulite",
"cellulitis",
"celluloid",
"cellulose",
"cellulosic",
"celom",
"celoma",
"celosia",
"celsius",
"celt",
"celtic",
"celtis",
"celtuce",
"cembalo",
"cement",
"cementite",
"cementum",
"cemetery",
"cenchrus",
"cenobite",
"cenogenesis",
"cenotaph",
"cenozoic",
"censer",
"censor",
"censoring",
"censorship",
"censure",
"census",
"cent",
"cental",
"centare",
"centas",
"centaur",
"centaurea",
"centaurium",
"centaurus",
"centaury",
"centavo",
"centenarian",
"centenary",
"centennial",
"center",
"centerboard",
"centerfield",
"centerfielder",
"centerfold",
"centering",
"centerline",
"centerpiece",
"centesimo",
"centesis",
"centile",
"centiliter",
"centilitre",
"centime",
"centimeter",
"centimetre",
"centimo",
"centipede",
"centner",
"central",
"centralisation",
"centralism",
"centrality",
"centralization",
"centranthus",
"centrarchid",
"centrarchidae",
"centre",
"centreboard",
"centrefold",
"centrepiece",
"centrex",
"centrifugation",
"centrifuge",
"centriole",
"centriscidae",
"centrism",
"centrist",
"centrocercus",
"centroid",
"centrolobium",
"centromere",
"centropomidae",
"centropomus",
"centropristis",
"centropus",
"centrosema",
"centrosome",
"centrospermae",
"centrum",
"centunculus",
"centurion",
"century",
"cephalalgia",
"cephalanthera",
"cephalaspid",
"cephalaspida",
"cephalexin",
"cephalhematoma",
"cephalitis",
"cephalobidae",
"cephalochordata",
"cephalochordate",
"cephaloglycin",
"cephalohematoma",
"cephalometry",
"cephalopod",
"cephalopoda",
"cephalopterus",
"cephaloridine",
"cephalosporin",
"cephalotaceae",
"cephalotaxaceae",
"cephalotaxus",
"cephalothin",
"cephalotus",
"cepheus",
"cepphus",
"cerambycidae",
"ceramic",
"ceramicist",
"ceramics",
"ceramist",
"cerapteryx",
"ceras",
"cerastes",
"cerastium",
"cerate",
"ceratin",
"ceratitis",
"ceratodontidae",
"ceratodus",
"ceratonia",
"ceratopetalum",
"ceratophyllum",
"ceratopogon",
"ceratopogonidae",
"ceratopsia",
"ceratopsian",
"ceratopsidae",
"ceratopteris",
"ceratosaur",
"ceratosaurus",
"ceratostomella",
"ceratotherium",
"ceratozamia",
"cerberus",
"cercaria",
"cercidiphyllum",
"cercidium",
"cercis",
"cercocebus",
"cercopidae",
"cercopithecidae",
"cercopithecus",
"cercospora",
"cercosporella",
"cere",
"cereal",
"cerebellum",
"cerebration",
"cerebrum",
"cerecloth",
"cerement",
"ceremonial",
"ceremoniousness",
"ceremony",
"ceres",
"ceresin",
"cereus",
"ceriman",
"cerise",
"cerium",
"cerivastatin",
"cero",
"ceroxylon",
"cert",
"certainty",
"certhia",
"certhiidae",
"certificate",
"certification",
"certiorari",
"certitude",
"cerulean",
"cerumen",
"ceruse",
"cerussite",
"cervantes",
"cervicitis",
"cervid",
"cervidae",
"cervix",
"cervus",
"ceryle",
"cesarean",
"cesarian",
"cesium",
"cessation",
"cession",
"cesspit",
"cesspool",
"cestida",
"cestidae",
"cestoda",
"cestode",
"cestrum",
"cestum",
"cetacea",
"cetacean",
"cetchup",
"ceterach",
"cetonia",
"cetoniidae",
"cetorhinidae",
"cetorhinus",
"cetraria",
"cetrimide",
"cetus",
"cewa",
"ceylon",
"ceylonite",
"cezanne",
"cftr",
"chabad",
"chabasite",
"chabazite",
"chablis",
"chachalaca",
"chachka",
"chacma",
"chad",
"chadar",
"chaddar",
"chadian",
"chadic",
"chadlock",
"chador",
"chaenactis",
"chaenomeles",
"chaenopsis",
"chaeronea",
"chaeta",
"chaetodipterus",
"chaetodon",
"chaetodontidae",
"chaetognath",
"chaetognatha",
"chafe",
"chafeweed",
"chaff",
"chaffinch",
"chaffweed",
"chafing",
"chaga",
"chagall",
"chagatai",
"chagga",
"chagrin",
"chahta",
"chain",
"chains",
"chainsaw",
"chair",
"chairlift",
"chairman",
"chairmanship",
"chairperson",
"chairwoman",
"chaise",
"chait",
"chaja",
"chalaza",
"chalazion",
"chalcanthite",
"chalcedon",
"chalcedony",
"chalcid",
"chalcidae",
"chalcidfly",
"chalcididae",
"chalcis",
"chalcocite",
"chalcopyrite",
"chalcostigma",
"chaldaea",
"chaldaean",
"chaldea",
"chaldean",
"chaldee",
"chaldron",
"chalet",
"chalice",
"chalk",
"chalkboard",
"chalkpit",
"chalkstone",
"challah",
"challenge",
"challenger",
"challis",
"chalons",
"chalybite",
"chamaea",
"chamaecrista",
"chamaecyparis",
"chamaecytisus",
"chamaedaphne",
"chamaeleo",
"chamaeleon",
"chamaeleonidae",
"chamaeleontidae",
"chamaemelum",
"chamber",
"chamberlain",
"chambermaid",
"chamberpot",
"chambers",
"chambray",
"chameleon",
"chamfer",
"chamfron",
"chammy",
"chamois",
"chamomile",
"chamosite",
"champ",
"champagne",
"champaign",
"champerty",
"champion",
"championship",
"champlain",
"champollion",
"chanal",
"chanar",
"chance",
"chancel",
"chancellery",
"chancellor",
"chancellorship",
"chancery",
"chancre",
"chancroid",
"chandelier",
"chandelle",
"chandi",
"chandler",
"chandlery",
"chanfron",
"chang",
"changan",
"change",
"changeability",
"changeableness",
"changefulness",
"changelessness",
"changeling",
"changeover",
"changer",
"changjiang",
"changtzu",
"channel",
"channelisation",
"channelization",
"channels",
"channidae",
"channukah",
"channukkah",
"chanoyu",
"chant",
"chantarelle",
"chanter",
"chanterelle",
"chantey",
"chanting",
"chantry",
"chanty",
"chanukah",
"chanukkah",
"chaos",
"chap",
"chaparral",
"chapati",
"chapatti",
"chapeau",
"chapel",
"chapelgoer",
"chaperon",
"chaperone",
"chapiter",
"chaplain",
"chaplaincy",
"chaplainship",
"chaplet",
"chaplin",
"chapman",
"chapter",
"chapterhouse",
"chapultepec",
"char",
"chara",
"charabanc",
"characeae",
"characid",
"characidae",
"characin",
"characinidae",
"character",
"characteristic",
"charade",
"charades",
"charadrii",
"charadriidae",
"charadriiformes",
"charadrius",
"charales",
"charcoal",
"charcot",
"charcuterie",
"chard",
"chardonnay",
"charge",
"chargeman",
"charger",
"chari",
"charina",
"chariness",
"chariot",
"charioteer",
"charisma",
"charitableness",
"charity",
"charivari",
"charlatan",
"charlatanism",
"charlemagne",
"charleroi",
"charles",
"charleston",
"charlestown",
"charlock",
"charlotte",
"charlottetown",
"charm",
"charmer",
"charnel",
"charolais",
"charon",
"charophyceae",
"charr",
"charronia",
"chart",
"charter",
"charterhouse",
"chartism",
"chartist",
"chartres",
"chartreuse",
"charwoman",
"charybdis",
"chase",
"chased",
"chaser",
"chasid",
"chasidim",
"chasidism",
"chasm",
"chasse",
"chassid",
"chassidim",
"chassidism",
"chassis",
"chasteness",
"chastening",
"chastisement",
"chastity",
"chasuble",
"chat",
"chateau",
"chateaubriand",
"chatelaine",
"chateura",
"chatroom",
"chattahoochee",
"chattanooga",
"chattel",
"chatter",
"chatterbox",
"chatterer",
"chattering",
"chaucer",
"chauffeur",
"chauffeuse",
"chaulmoogra",
"chaulmugra",
"chauna",
"chauvinism",
"chauvinist",
"chavez",
"chaw",
"chawbacon",
"cheapjack",
"cheapness",
"cheapskate",
"cheat",
"cheater",
"cheatgrass",
"cheating",
"chebab",
"chechen",
"chechenia",
"chechnya",
"check",
"checkbook",
"checker",
"checkerberry",
"checkerbloom",
"checkerboard",
"checkers",
"checklist",
"checkmate",
"checkout",
"checkpoint",
"checkrein",
"checkroom",
"checksum",
"checkup",
"cheddar",
"cheek",
"cheekbone",
"cheekiness",
"cheekpiece",
"cheep",
"cheer",
"cheerer",
"cheerfulness",
"cheering",
"cheerio",
"cheerleader",
"cheerlessness",
"cheese",
"cheeseboard",
"cheeseburger",
"cheesecake",
"cheesecloth",
"cheeseflower",
"cheesemonger",
"cheetah",
"cheever",
"cheewink",
"chef",
"cheilanthes",
"cheilitis",
"cheiloschisis",
"cheilosis",
"cheiranthus",
"chekhov",
"chekov",
"chela",
"chelate",
"chelation",
"chelicera",
"chelicerata",
"chelidonium",
"chelifer",
"cheloid",
"chelone",
"chelonethida",
"chelonia",
"chelonian",
"chelonidae",
"cheloniidae",
"chelyabinsk",
"chelydra",
"chelydridae",
"chemakuan",
"chemakum",
"chemical",
"chemise",
"chemisorption",
"chemist",
"chemistry",
"chemnitz",
"chemoimmunology",
"chemoreceptor",
"chemosis",
"chemosorption",
"chemosurgery",
"chemosynthesis",
"chemotaxis",
"chemotherapy",
"chemulpo",
"chen",
"chenfish",
"chenille",
"chennai",
"chenopodiaceae",
"chenopodiales",
"chenopodium",
"cheops",
"cheque",
"chequebook",
"chequer",
"cherbourg",
"cheremis",
"cheremiss",
"cherepovets",
"cherimolla",
"cherimoya",
"chermidae",
"chernobyl",
"cherokee",
"cheroot",
"cherry",
"cherrystone",
"chert",
"cherub",
"cherubini",
"chervil",
"chess",
"chessboard",
"chessman",
"chest",
"chester",
"chesterfield",
"chesterton",
"chestnut",
"chetah",
"chetrum",
"chevalier",
"cheviot",
"cheviots",
"chevre",
"chevron",
"chevrotain",
"chew",
"chewa",
"chewer",
"chewing",
"chewink",
"cheyenne",
"chianti",
"chiaroscuro",
"chiasm",
"chiasma",
"chiasmus",
"chic",
"chicago",
"chicane",
"chicanery",
"chicano",
"chicha",
"chichewa",
"chichi",
"chichipe",
"chick",
"chickadee",
"chickamauga",
"chickasaw",
"chicken",
"chickenfeed",
"chickenpox",
"chickenshit",
"chickeree",
"chickpea",
"chickweed",
"chicle",
"chicness",
"chico",
"chicory",
"chicot",
"chiding",
"chief",
"chieftain",
"chieftaincy",
"chieftainship",
"chiffon",
"chiffonier",
"chigetai",
"chigger",
"chiggerflower",
"chignon",
"chigoe",
"chihuahua",
"chilblain",
"chilblains",
"child",
"childbearing",
"childbed",
"childbirth",
"childcare",
"childhood",
"childishness",
"childlessness",
"chile",
"chilean",
"chili",
"chiliad",
"chiliasm",
"chiliast",
"chill",
"chiller",
"chilli",
"chilliness",
"chilling",
"chilly",
"chiloe",
"chilomastix",
"chilomeniscus",
"chilomycterus",
"chilopoda",
"chilopsis",
"chiluba",
"chimaera",
"chimaeridae",
"chimakum",
"chimaphila",
"chimariko",
"chimborazo",
"chime",
"chimera",
"chimney",
"chimneypiece",
"chimneypot",
"chimneystack",
"chimneysweep",
"chimneysweeper",
"chimonanthus",
"chimp",
"chimpanzee",
"chimwini",
"chin",
"china",
"chinaberry",
"chinaman",
"chinaware",
"chincapin",
"chinch",
"chincherinchee",
"chinchilla",
"chinchillidae",
"chinchillon",
"chinchona",
"chine",
"chinese",
"chingpo",
"chink",
"chinkapin",
"chino",
"chinoiserie",
"chinook",
"chinookan",
"chinos",
"chinquapin",
"chintz",
"chiococca",
"chionanthus",
"chios",
"chip",
"chipboard",
"chipewyan",
"chipmunk",
"chipolata",
"chipotle",
"chippendale",
"chippewa",
"chippewaian",
"chippewyan",
"chipping",
"chips",
"chiralgia",
"chirico",
"chirocephalus",
"chirography",
"chirology",
"chiromancer",
"chiromancy",
"chiron",
"chironomidae",
"chironomus",
"chiropodist",
"chiropody",
"chiropractic",
"chiropractor",
"chiroptera",
"chiropteran",
"chirp",
"chirpiness",
"chirrup",
"chisel",
"chiseler",
"chiseller",
"chishona",
"chisinau",
"chislev",
"chit",
"chitchat",
"chitin",
"chitlings",
"chitlins",
"chiton",
"chittagong",
"chittamwood",
"chitterlings",
"chittimwood",
"chivalry",
"chivaree",
"chive",
"chives",
"chiwere",
"chlamydera",
"chlamydia",
"chlamydiaceae",
"chlamydomonas",
"chlamydosaurus",
"chlamydospore",
"chlamyphore",
"chlamyphorus",
"chlamys",
"chloasma",
"chlorambucil",
"chloramine",
"chloramphenicol",
"chloranthaceae",
"chloranthus",
"chlorate",
"chlorella",
"chlorenchyma",
"chlorhexidine",
"chloride",
"chlorination",
"chlorine",
"chlorinity",
"chloris",
"chlorite",
"chlorobenzene",
"chlorococcales",
"chlorococcum",
"chloroform",
"chlorofucin",
"chloromycetin",
"chlorophis",
"chlorophoneus",
"chlorophyceae",
"chlorophyl",
"chlorophyll",
"chlorophyta",
"chlorophyte",
"chloropicrin",
"chloroplast",
"chloroprene",
"chloroquine",
"chlorosis",
"chlorothiazide",
"chloroxylon",
"chlorpromazine",
"chlorpyrifos",
"chlorthalidone",
"chlorura",
"choanocyte",
"choc",
"chock",
"chocolate",
"choctaw",
"choeronycteris",
"choice",
"choiceness",
"choir",
"choirboy",
"choirmaster",
"choke",
"chokecherry",
"chokedamp",
"chokehold",
"chokepoint",
"choker",
"chokey",
"choking",
"choky",
"cholangiography",
"cholangitis",
"cholecalciferol",
"cholecystectomy",
"cholecystitis",
"cholecystokinin",
"cholelithiasis",
"cholelithotomy",
"choler",
"cholera",
"cholestasis",
"cholesterin",
"cholesterol",
"choline",
"cholinesterase",
"cholla",
"choloepus",
"chomp",
"chomping",
"chomsky",
"chon",
"chondrichthian",
"chondrichthyes",
"chondrin",
"chondriosome",
"chondrite",
"chondroma",
"chondrosarcoma",
"chondrule",
"chondrus",
"chongqing",
"chooser",
"chop",
"chophouse",
"chopin",
"chopine",
"chopper",
"choppiness",
"chopsteak",
"chopstick",
"choragus",
"choral",
"chorale",
"chord",
"chordamesoderm",
"chordata",
"chordate",
"chordeiles",
"chorditis",
"chordomesoderm",
"chordophone",
"chordospartium",
"chore",
"chorea",
"choreographer",
"choreography",
"chorine",
"chorioallantois",
"chorion",
"chorioretinitis",
"choriotis",
"chorister",
"chorizagrotis",
"chorizema",
"chorizo",
"choroid",
"chortle",
"chorus",
"chosen",
"chou",
"chough",
"chow",
"chowchow",
"chowder",
"chrestomathy",
"chrism",
"chrisom",
"christ",
"christchurch",
"christella",
"christendom",
"christening",
"christian",
"christiania",
"christianity",
"christie",
"christmas",
"christmasberry",
"christmastide",
"christmastime",
"christology",
"christopher",
"chroma",
"chromaesthesia",
"chromate",
"chromaticity",
"chromatid",
"chromatin",
"chromatism",
"chromatogram",
"chromatography",
"chrome",
"chromesthesia",
"chromite",
"chromium",
"chromogen",
"chromophore",
"chromoplast",
"chromosome",
"chromosphere",
"chronicle",
"chronicler",
"chronograph",
"chronology",
"chronometer",
"chronoperates",
"chronoscope",
"chrysalis",
"chrysanthemum",
"chrysaora",
"chrysarobin",
"chrysemys",
"chrysobalanus",
"chrysoberyl",
"chrysochloridae",
"chrysochloris",
"chrysolepis",
"chrysolite",
"chrysolophus",
"chrysomelid",
"chrysomelidae",
"chrysophrys",
"chrysophyceae",
"chrysophyllum",
"chrysophyta",
"chrysopid",
"chrysopidae",
"chrysoprase",
"chrysopsis",
"chrysosplenium",
"chrysothamnus",
"chrysotherapy",
"chrysotile",
"chub",
"chubbiness",
"chuck",
"chuckhole",
"chuckle",
"chuckwalla",
"chuddar",
"chufa",
"chug",
"chukchi",
"chukka",
"chukker",
"chum",
"chumminess",
"chump",
"chunga",
"chungking",
"chunk",
"chunking",
"chunnel",
"church",
"churchgoer",
"churchill",
"churchman",
"churchwarden",
"churchyard",
"churidars",
"churl",
"churn",
"chute",
"chutney",
"chutzpa",
"chutzpah",
"chutzpanik",
"chuvash",
"chyle",
"chyloderma",
"chylomicron",
"chyme",
"chymosin",
"chytridiaceae",
"chytridiales",
"cialis",
"ciao",
"ciardi",
"cibotium",
"cicada",
"cicadellidae",
"cicadidae",
"cicala",
"cicatrice",
"cicatrix",
"cicer",
"cicero",
"cicerone",
"cichlid",
"cichlidae",
"cichorium",
"cicindelidae",
"ciconia",
"ciconiidae",
"ciconiiformes",
"cicuta",
"cider",
"ciderpress",
"cigar",
"cigaret",
"cigarette",
"cigarfish",
"cigarillo",
"cilantro",
"ciliata",
"ciliate",
"cilioflagellata",
"ciliophora",
"ciliophoran",
"cilium",
"cimabue",
"cimarron",
"cimetidine",
"cimex",
"cimicidae",
"cimicifuga",
"cinch",
"cinchona",
"cinchonine",
"cincinnati",
"cincinnatus",
"cinclidae",
"cinclus",
"cincture",
"cinder",
"cinderella",
"cinema",
"cinematographer",
"cinematography",
"cineraria",
"cinerarium",
"cingulum",
"cinnabar",
"cinnamene",
"cinnamomum",
"cinnamon",
"cinque",
"cinquefoil",
"cipher",
"cipro",
"ciprofloxacin",
"cira",
"circaea",
"circaetus",
"circassian",
"circe",
"circinus",
"circle",
"circlet",
"circuit",
"circuitry",
"circular",
"circularisation",
"circularity",
"circularization",
"circulation",
"circumcision",
"circumduction",
"circumference",
"circumflex",
"circumlocution",
"circumscription",
"circumspection",
"circumstance",
"circumstances",
"circumvention",
"circumvolution",
"circus",
"cirio",
"cirque",
"cirrhosis",
"cirrhus",
"cirriped",
"cirripede",
"cirripedia",
"cirrocumulus",
"cirrostratus",
"cirrus",
"cirsium",
"cisc",
"cisco",
"cistaceae",
"cistercian",
"cistern",
"cisterna",
"cistothorus",
"cistron",
"cistus",
"citadel",
"citation",
"cite",
"citellus",
"citharichthys",
"cither",
"cithern",
"citizen",
"citizenry",
"citizenship",
"citlaltepetl",
"citole",
"citrange",
"citrate",
"citrin",
"citrine",
"citron",
"citroncirus",
"citronwood",
"citrulline",
"citrullus",
"citrus",
"cittern",
"city",
"cityscape",
"cive",
"civet",
"civics",
"civies",
"civilian",
"civilisation",
"civility",
"civilization",
"civvies",
"clabber",
"clack",
"cladding",
"clade",
"cladistics",
"cladode",
"cladogram",
"cladonia",
"cladoniaceae",
"cladophyll",
"cladorhyncus",
"cladrastis",
"claforan",
"claim",
"claimant",
"clairvoyance",
"clairvoyant",
"clam",
"clamatores",
"clambake",
"clamber",
"clamminess",
"clammyweed",
"clamor",
"clamoring",
"clamour",
"clamouring",
"clamp",
"clampdown",
"clams",
"clamshell",
"clan",
"clang",
"clanger",
"clangor",
"clangoring",
"clangour",
"clangula",
"clank",
"clannishness",
"clansman",
"clanswoman",
"clap",
"clapboard",
"clapper",
"clapperboard",
"clappers",
"clapping",
"claptrap",
"claque",
"clarence",
"claret",
"clarification",
"clarinet",
"clarinetist",
"clarinettist",
"clarion",
"clarity",
"clark",
"clarksburg",
"claro",
"clary",
"clash",
"clasp",
"class",
"classic",
"classical",
"classicalism",
"classicism",
"classicist",
"classics",
"classification",
"classified",
"classifier",
"classmate",
"classroom",
"classwork",
"clast",
"clathraceae",
"clathrus",
"clatter",
"claudication",
"claudius",
"clause",
"clausewitz",
"claustrophobe",
"claustrophobia",
"claustrum",
"clavariaceae",
"claviceps",
"clavichord",
"clavicipitaceae",
"clavicle",
"clavier",
"clavus",
"claw",
"clawback",
"clawfoot",
"clawhammer",
"claxon",
"clay",
"claymore",
"claystone",
"claytonia",
"clayware",
"clean",
"cleaner",
"cleaners",
"cleaning",
"cleanliness",
"cleanness",
"cleanser",
"cleansing",
"cleanthes",
"cleanup",
"clear",
"clearance",
"clearcutness",
"clearing",
"clearness",
"clearstory",
"clearway",
"clearweed",
"cleat",
"cleats",
"cleavage",
"cleaver",
"cleavers",
"clef",
"cleft",
"cleg",
"clegg",
"cleistes",
"cleistocarp",
"cleistogamy",
"cleistothecium",
"clematis",
"clemenceau",
"clemency",
"clemens",
"clementine",
"clench",
"cleome",
"cleopatra",
"clepsydra",
"clerestory",
"clergy",
"clergyman",
"cleric",
"clericalism",
"clericalist",
"clerid",
"cleridae",
"clerihew",
"clerisy",
"clerk",
"clerking",
"clerkship",
"clethra",
"clethraceae",
"clethrionomys",
"cleveland",
"cleverness",
"clevis",
"clew",
"clews",
"clianthus",
"cliche",
"clichy",
"click",
"client",
"clientage",
"clientele",
"cliff",
"cliffhanger",
"cliftonia",
"climacteric",
"climate",
"climatologist",
"climatology",
"climax",
"climb",
"climber",
"climbing",
"clime",
"clinch",
"clincher",
"cline",
"cling",
"clingfilm",
"clingfish",
"clingstone",
"clinic",
"clinician",
"clinid",
"clinidae",
"clink",
"clinker",
"clinocephalism",
"clinocephaly",
"clinodactyly",
"clinometer",
"clinopodium",
"clinoril",
"clinton",
"clintonia",
"clio",
"clioquinol",
"clip",
"clipboard",
"clipper",
"clipping",
"clique",
"cliquishness",
"clit",
"clitocybe",
"clitoria",
"clitoridectomy",
"clitoris",
"clive",
"clivers",
"cloaca",
"cloak",
"cloakmaker",
"cloakroom",
"clobber",
"clochard",
"cloche",
"clock",
"clocking",
"clockmaker",
"clocks",
"clocksmith",
"clockwork",
"clod",
"clodhopper",
"clofibrate",
"clog",
"cloisonne",
"cloister",
"clomid",
"clomiphene",
"clomipramine",
"clon",
"clone",
"clonidine",
"cloning",
"clonus",
"clop",
"clopping",
"clorox",
"close",
"closedown",
"closeness",
"closeout",
"closer",
"closet",
"closeup",
"closing",
"clostridia",
"clostridium",
"closure",
"clot",
"clotbur",
"cloth",
"clothes",
"clothesbrush",
"clotheshorse",
"clothesline",
"clothespin",
"clothespress",
"clothier",
"clothing",
"clotho",
"clotting",
"cloture",
"cloud",
"cloudberry",
"cloudburst",
"cloudiness",
"clouding",
"cloudlessness",
"clout",
"clove",
"clover",
"cloverleaf",
"cloveroot",
"clovis",
"clowder",
"clown",
"clowning",
"clozapine",
"clozaril",
"club",
"clubbing",
"clubfoot",
"clubhead",
"clubhouse",
"clubroom",
"cluck",
"clucking",
"clue",
"clumber",
"clump",
"clumping",
"clumsiness",
"clunch",
"clunk",
"clunking",
"clupea",
"clupeid",
"clupeidae",
"clusia",
"clusiaceae",
"cluster",
"clustering",
"clutch",
"clutches",
"clutter",
"clyde",
"clydesdale",
"clypeus",
"clyster",
"clytemnestra",
"cmbr",
"cnemidophorus",
"cnicus",
"cnidaria",
"cnidarian",
"cnidoscolus",
"cnidosporidia",
"cnossos",
"cnossus",
"cnpz",
"cnut",
"coach",
"coachbuilder",
"coaching",
"coachman",
"coachwhip",
"coaction",
"coadjutor",
"coagulant",
"coagulase",
"coagulation",
"coagulator",
"coagulum",
"coahuila",
"coal",
"coalbin",
"coalescence",
"coalescency",
"coalface",
"coalfield",
"coalhole",
"coalition",
"coalman",
"coalpit",
"coaming",
"coarctation",
"coarseness",
"coast",
"coaster",
"coastguard",
"coastguardsman",
"coastland",
"coastline",
"coat",
"coatdress",
"coatee",
"coati",
"coating",
"coatrack",
"coatroom",
"coattail",
"coauthor",
"coax",
"coaxer",
"coaxing",
"cobalamin",
"cobalt",
"cobaltite",
"cobber",
"cobble",
"cobbler",
"cobblers",
"cobblestone",
"cobbling",
"cobia",
"cobitidae",
"cobnut",
"cobol",
"cobra",
"cobweb",
"coca",
"cocain",
"cocaine",
"cocarboxylase",
"cocci",
"coccidae",
"coccidia",
"coccidiomycosis",
"coccidiosis",
"coccidium",
"coccinellidae",
"coccobacillus",
"coccoidea",
"coccothraustes",
"cocculus",
"coccus",
"coccyx",
"coccyzus",
"cochimi",
"cochin",
"cochineal",
"cochise",
"cochlea",
"cochlearia",
"cochlearius",
"cochran",
"cock",
"cockade",
"cockaigne",
"cockateel",
"cockatiel",
"cockatoo",
"cockatrice",
"cockchafer",
"cockcroft",
"cockcrow",
"cocker",
"cockerel",
"cockfight",
"cockfighting",
"cockhorse",
"cockiness",
"cockle",
"cocklebur",
"cockleburr",
"cockleshell",
"cockloft",
"cockney",
"cockpit",
"cockroach",
"cockscomb",
"cocksfoot",
"cockspur",
"cocksucker",
"cocksureness",
"cocktail",
"cockup",
"coco",
"cocoa",
"cocoanut",
"cocobolo",
"coconspirator",
"coconut",
"cocoon",
"cocooning",
"cocopa",
"cocopah",
"cocos",
"cocoswood",
"cocotte",
"cocoyam",
"cocozelle",
"cocteau",
"cocus",
"cocuswood",
"cocytus",
"coda",
"codariocalyx",
"coddler",
"code",
"codefendant",
"codeine",
"coder",
"codetalker",
"codex",
"codfish",
"codger",
"codiaeum",
"codicil",
"codification",
"coding",
"codling",
"codon",
"codpiece",
"codswallop",
"cody",
"coeducation",
"coefficient",
"coelacanth",
"coelenterata",
"coelenterate",
"coelenteron",
"coeloglossum",
"coelogyne",
"coelom",
"coelophysis",
"coelostat",
"coenobite",
"coenzyme",
"coercion",
"coereba",
"coerebidae",
"coeval",
"coevals",
"coexistence",
"coextension",
"cofactor",
"coffea",
"coffee",
"coffeeberry",
"coffeecake",
"coffeehouse",
"coffeepot",
"coffer",
"cofferdam",
"coffin",
"cofounder",
"cogency",
"cogitation",
"cognac",
"cognate",
"cognation",
"cognisance",
"cognition",
"cognizance",
"cognomen",
"cognoscente",
"cogwheel",
"cohabitation",
"cohan",
"coherence",
"coherency",
"cohesion",
"cohesiveness",
"cohn",
"coho",
"cohoe",
"cohort",
"cohosh",
"cohune",
"coif",
"coiffeur",
"coiffeuse",
"coiffure",
"coign",
"coigne",
"coigue",
"coil",
"coin",
"coinage",
"coincidence",
"coiner",
"coinsurance",
"coir",
"coition",
"coitus",
"coke",
"cola",
"colander",
"colaptes",
"colbert",
"colchicaceae",
"colchicine",
"colchicum",
"colchis",
"cold",
"coldcream",
"coldheartedness",
"coldness",
"cole",
"coleonyx",
"coleoptera",
"coleridge",
"coleslaw",
"colette",
"coleus",
"colewort",
"colic",
"colicroot",
"colima",
"colinus",
"coliphage",
"coliseum",
"colitis",
"collaboration",
"collaborator",
"collage",
"collagen",
"collagenase",
"collapse",
"collar",
"collarbone",
"collard",
"collards",
"collateral",
"collation",
"colleague",
"collect",
"collectable",
"collectible",
"collecting",
"collection",
"collective",
"collectivism",
"collectivist",
"collector",
"colleen",
"college",
"collegian",
"collembola",
"collembolan",
"collet",
"collider",
"collie",
"collier",
"colliery",
"colligation",
"collimation",
"collimator",
"collins",
"collinsia",
"collinsonia",
"collision",
"collocalia",
"collocation",
"collodion",
"colloid",
"colloquialism",
"colloquium",
"colloquy",
"collotype",
"collusion",
"collyrium",
"collywobbles",
"colobus",
"colocasia",
"cologne",
"colombia",
"colombian",
"colombo",
"colon",
"colonel",
"colonial",
"colonialism",
"colonialist",
"colonic",
"colonisation",
"coloniser",
"colonist",
"colonization",
"colonizer",
"colonnade",
"colonoscope",
"colonoscopy",
"colony",
"colophon",
"colophony",
"color",
"coloradan",
"coloradillo",
"colorado",
"coloration",
"coloratura",
"colorcast",
"colorimeter",
"colorimetry",
"coloring",
"colorist",
"colorlessness",
"colors",
"colossae",
"colosseum",
"colossian",
"colossians",
"colossus",
"colostomy",
"colostrum",
"colour",
"colouration",
"colourcast",
"colouring",
"colourlessness",
"colours",
"colpitis",
"colpocele",
"colpocystitis",
"colpocystocele",
"colpoxerosis",
"colt",
"coltan",
"colter",
"coltsfoot",
"coluber",
"colubrid",
"colubridae",
"colubrina",
"colugo",
"columba",
"columbarium",
"columbary",
"columbia",
"columbidae",
"columbiformes",
"columbine",
"columbite",
"columbium",
"columbo",
"columbus",
"columella",
"column",
"columnea",
"columniation",
"columnist",
"colutea",
"colymbiformes",
"colza",
"coma",
"comanche",
"comandra",
"comatoseness",
"comatula",
"comatulid",
"comatulidae",
"comb",
"combat",
"combatant",
"combativeness",
"comber",
"combination",
"combine",
"combing",
"combining",
"combo",
"combretaceae",
"combretum",
"combustibility",
"combustible",
"combustibleness",
"combustion",
"come",
"comeback",
"comedian",
"comedienne",
"comedo",
"comedown",
"comedy",
"comeliness",
"comenius",
"comer",
"comestible",
"comet",
"comeupance",
"comeuppance",
"comfit",
"comfort",
"comfortableness",
"comforter",
"comforts",
"comfrey",
"comic",
"comicality",
"coming",
"comint",
"comity",
"comma",
"command",
"commandant",
"commander",
"commandership",
"commandery",
"commandment",
"commando",
"commelina",
"commelinaceae",
"commelinales",
"commelinidae",
"commemoration",
"commemorative",
"commencement",
"commendation",
"commensal",
"commensalism",
"comment",
"commentary",
"commentator",
"commerce",
"commercial",
"commercialism",
"commie",
"commination",
"commiphora",
"commiseration",
"commissar",
"commissariat",
"commissary",
"commission",
"commissionaire",
"commissioner",
"commissioning",
"commissure",
"commitment",
"committal",
"committedness",
"committee",
"committeeman",
"committeewoman",
"commixture",
"commode",
"commodiousness",
"commodity",
"commodore",
"common",
"commonage",
"commonality",
"commonalty",
"commoner",
"commonness",
"commonplace",
"commonplaceness",
"commons",
"commonweal",
"commonwealth",
"commotion",
"communalism",
"commune",
"communicant",
"communicating",
"communication",
"communications",
"communicator",
"communion",
"communique",
"communisation",
"communism",
"communist",
"community",
"communization",
"commutability",
"commutation",
"commutator",
"commute",
"commuter",
"commuting",
"comoros",
"comp",
"compact",
"compaction",
"compactness",
"companion",
"companionship",
"companionway",
"company",
"comparability",
"comparative",
"compare",
"comparing",
"comparison",
"compartment",
"compass",
"compassion",
"compatibility",
"compatriot",
"compeer",
"compendium",
"compensation",
"compere",
"competence",
"competency",
"competition",
"competitiveness",
"competitor",
"compilation",
"compiler",
"compiling",
"complacence",
"complacency",
"complainant",
"complainer",
"complaint",
"complaisance",
"complement",
"complementarity",
"complementary",
"complementation",
"completeness",
"completion",
"complex",
"complexifier",
"complexion",
"complexity",
"complexness",
"compliance",
"compliancy",
"complicatedness",
"complication",
"complicity",
"compliment",
"compliments",
"complin",
"compline",
"component",
"comportment",
"composer",
"composing",
"compositae",
"composite",
"compositeness",
"composition",
"compositor",
"compost",
"composure",
"compote",
"compound",
"compounding",
"comprehension",
"comprehensive",
"compress",
"compressibility",
"compressing",
"compression",
"compressor",
"compromise",
"compromiser",
"compsognathus",
"compton",
"comptonia",
"comptroller",
"comptrollership",
"compulsion",
"compulsive",
"compulsiveness",
"compulsivity",
"compunction",
"computation",
"computer",
"computerization",
"computing",
"comrade",
"comradeliness",
"comradery",
"comradeship",
"comstock",
"comstockery",
"comte",
"comtism",
"conacaste",
"conakry",
"concatenation",
"concaveness",
"concavity",
"concealing",
"concealment",
"conceding",
"conceit",
"conceitedness",
"conceivability",
"conceivableness",
"conceiver",
"concentrate",
"concentration",
"concentricity",
"concepcion",
"concept",
"conception",
"conceptualism",
"conceptuality",
"conceptus",
"concern",
"concert",
"concertina",
"concertinist",
"concerto",
"concession",
"concessionaire",
"concessioner",
"conch",
"concha",
"conchfish",
"conchologist",
"conchology",
"concierge",
"conciliation",
"conciliator",
"conciseness",
"concision",
"conclave",
"conclusion",
"conclusiveness",
"concoction",
"concomitance",
"concomitant",
"concord",
"concordance",
"concordat",
"concourse",
"concrete",
"concreteness",
"concretion",
"concretism",
"concubinage",
"concubine",
"concupiscence",
"concurrence",
"concurrency",
"concussion",
"condemnation",
"condensate",
"condensation",
"condenser",
"condensing",
"condescension",
"condiment",
"condition",
"conditionality",
"conditioner",
"conditioning",
"conditions",
"condo",
"condolence",
"condom",
"condominium",
"condonation",
"condor",
"condorcet",
"conduct",
"conductance",
"conducting",
"conduction",
"conductivity",
"conductor",
"conductress",
"conduit",
"condyle",
"condylion",
"condylura",
"cone",
"coneflower",
"conenose",
"conepatus",
"conessi",
"conestoga",
"coney",
"confab",
"confabulation",
"confect",
"confection",
"confectionary",
"confectioner",
"confectionery",
"confederacy",
"confederate",
"confederation",
"conferee",
"conference",
"conferment",
"conferral",
"conferrer",
"conferva",
"confession",
"confessional",
"confessor",
"confetti",
"confidant",
"confidante",
"confidence",
"confidentiality",
"configuration",
"confinement",
"confines",
"confirmation",
"confiscation",
"confit",
"confiture",
"conflagration",
"conflict",
"confluence",
"confluent",
"conflux",
"conformance",
"conformation",
"conformism",
"conformist",
"conformity",
"confrere",
"confrontation",
"confucian",
"confucianism",
"confucianist",
"confucius",
"confusedness",
"confusion",
"confutation",
"confuter",
"conga",
"conge",
"congealment",
"congee",
"congelation",
"congenator",
"congener",
"congeneric",
"congeniality",
"congenialness",
"conger",
"congeries",
"congestion",
"congius",
"conglobation",
"conglomerate",
"conglomeration",
"conglutination",
"congo",
"congolese",
"congou",
"congratulation",
"congratulations",
"congregant",
"congregating",
"congregation",
"congress",
"congressman",
"congresswoman",
"congreve",
"congridae",
"congruence",
"congruity",
"congruousness",
"conic",
"conidiophore",
"conidiospore",
"conidium",
"conifer",
"coniferales",
"coniferophyta",
"coniferophytina",
"coniferopsida",
"conilurus",
"conima",
"coniogramme",
"conium",
"conjecture",
"conjugate",
"conjugation",
"conjunction",
"conjunctiva",
"conjunctive",
"conjunctivitis",
"conjuncture",
"conjuration",
"conjurer",
"conjuring",
"conjuror",
"conjury",
"conk",
"conker",
"connaraceae",
"connarus",
"connectedness",
"connecter",
"connecticut",
"connecticuter",
"connection",
"connective",
"connectivity",
"connector",
"connexion",
"conniption",
"connivance",
"connochaetes",
"connoisseur",
"connoisseurship",
"connolly",
"connors",
"connotation",
"conocarpus",
"conoclinium",
"conodont",
"conodonta",
"conoid",
"conopodium",
"conospermum",
"conoy",
"conquering",
"conqueror",
"conquest",
"conquistador",
"conrad",
"conradina",
"consanguinity",
"conscience",
"consciousness",
"conscript",
"conscription",
"consecration",
"consensus",
"consent",
"consequence",
"conservancy",
"conservation",
"conservationist",
"conservatism",
"conservative",
"conservativism",
"conservativist",
"conservatoire",
"conservator",
"conservatory",
"conserve",
"conserves",
"considerateness",
"consideration",
"consignee",
"consigner",
"consignment",
"consignor",
"consistence",
"consistency",
"consistory",
"consolation",
"console",
"consolida",
"consolidation",
"consomme",
"consonance",
"consonant",
"consort",
"consortium",
"conspecific",
"conspectus",
"conspicuousness",
"conspiracy",
"conspirator",
"constable",
"constabulary",
"constance",
"constancy",
"constant",
"constantan",
"constantina",
"constantine",
"constantinople",
"constatation",
"constellation",
"consternation",
"constipation",
"constituency",
"constituent",
"constitution",
"constitutional",
"constraint",
"constriction",
"constrictor",
"construal",
"construct",
"construction",
"constructivism",
"constructivist",
"constructor",
"consuetude",
"consuetudinal",
"consuetudinary",
"consul",
"consulate",
"consulship",
"consultancy",
"consultant",
"consultation",
"consumer",
"consumerism",
"consummation",
"consumption",
"consumptive",
"contact",
"contadino",
"contagion",
"container",
"containerful",
"containership",
"containment",
"contaminant",
"contamination",
"contemplation",
"contemplative",
"contemporaneity",
"contemporaries",
"contemporary",
"contempt",
"contemptibility",
"contender",
"content",
"contentedness",
"contention",
"contentiousness",
"contentment",
"contents",
"contest",
"contestant",
"contestation",
"contestee",
"contester",
"context",
"contextualism",
"contiguity",
"contiguousness",
"continence",
"continency",
"continent",
"contingence",
"contingency",
"contingent",
"continuance",
"continuant",
"continuation",
"continuative",
"continuity",
"continuo",
"continuousness",
"continuum",
"conto",
"contopus",
"contortion",
"contortionist",
"contour",
"contra",
"contraband",
"contrabandist",
"contrabass",
"contrabassoon",
"contraception",
"contraceptive",
"contract",
"contractility",
"contracting",
"contraction",
"contractor",
"contracture",
"contradance",
"contradiction",
"contradictory",
"contrafagotto",
"contrail",
"contralto",
"contraption",
"contrapuntist",
"contrarian",
"contrariety",
"contrariness",
"contrary",
"contras",
"contrast",
"contravention",
"contredanse",
"contretemps",
"contribution",
"contributor",
"contriteness",
"contrition",
"contrivance",
"contriver",
"control",
"controller",
"controllership",
"controversy",
"contumacy",
"contumely",
"contusion",
"conundrum",
"conurbation",
"conuropsis",
"convalescence",
"convalescent",
"convallaria",
"convallariaceae",
"convection",
"convector",
"convener",
"convenience",
"conveniences",
"convening",
"convent",
"conventicle",
"convention",
"conventionalism",
"conventionality",
"conventioneer",
"convergence",
"convergency",
"converging",
"conversance",
"conversancy",
"conversation",
"conversationist",
"converse",
"conversion",
"converso",
"convert",
"converter",
"convertibility",
"convertible",
"convertor",
"convexity",
"convexness",
"conveyance",
"conveyancer",
"conveyancing",
"conveyer",
"conveying",
"conveyor",
"convict",
"convictfish",
"conviction",
"convincingness",
"conviviality",
"convocation",
"convolution",
"convolvulaceae",
"convolvulus",
"convoy",
"convulsion",
"cony",
"conyza",
"cook",
"cookbook",
"cooke",
"cooker",
"cookery",
"cookfire",
"cookhouse",
"cookie",
"cooking",
"cookout",
"cookstove",
"cookware",
"cooky",
"cool",
"coolant",
"cooler",
"coolidge",
"coolie",
"cooling",
"coolness",
"coolwart",
"cooly",
"coon",
"coondog",
"coonhound",
"coonskin",
"coontie",
"coop",
"cooper",
"cooperation",
"cooperative",
"cooperativeness",
"cooperator",
"cooperstown",
"coordinate",
"coordination",
"coordinator",
"coosa",
"coot",
"cooter",
"cootie",
"copaiba",
"copal",
"copaline",
"copalite",
"copartner",
"copartnership",
"cope",
"copeck",
"copehan",
"copenhagen",
"copepod",
"copepoda",
"copernicia",
"copernicus",
"copestone",
"copier",
"copilot",
"coping",
"copiousness",
"copland",
"copley",
"copolymer",
"copout",
"copper",
"copperhead",
"copperplate",
"coppersmith",
"copperware",
"coppice",
"coppola",
"copra",
"coprinaceae",
"coprinus",
"coprolalia",
"coprolite",
"coprolith",
"coprophagia",
"coprophagy",
"copse",
"copt",
"coptic",
"coptis",
"copula",
"copulation",
"copulative",
"copy",
"copybook",
"copycat",
"copyhold",
"copyholder",
"copying",
"copyist",
"copyreader",
"copyright",
"copywriter",
"coquetry",
"coquette",
"coquille",
"cora",
"coracan",
"coracias",
"coraciidae",
"coraciiformes",
"coracle",
"coragyps",
"corakan",
"coral",
"coralbells",
"coralberry",
"corallorhiza",
"coralroot",
"coralwood",
"coralwort",
"corbel",
"corbett",
"corbiestep",
"corbina",
"corchorus",
"cord",
"cordage",
"cordaitaceae",
"cordaitales",
"cordaites",
"cordarone",
"corday",
"cordgrass",
"cordia",
"cordial",
"cordiality",
"cordierite",
"cordite",
"corditis",
"cordoba",
"cordon",
"cordova",
"cordovan",
"cords",
"corduroy",
"corduroys",
"cordwood",
"cordylidae",
"cordyline",
"cordylus",
"core",
"coreference",
"coregonidae",
"coregonus",
"coreid",
"coreidae",
"coreligionist",
"corelli",
"coreopsis",
"corer",
"corespondent",
"corgard",
"corgi",
"coriander",
"coriandrum",
"coricidin",
"corinth",
"corinthian",
"corium",
"corixa",
"corixidae",
"cork",
"corkage",
"corkboard",
"corker",
"corkscrew",
"corkwood",
"corm",
"cormorant",
"corn",
"cornaceae",
"cornbread",
"corncob",
"corncrake",
"corncrib",
"cornea",
"corneille",
"cornel",
"cornelian",
"cornell",
"corner",
"cornerback",
"cornerstone",
"cornet",
"cornetfish",
"cornetist",
"corneum",
"cornfield",
"cornflour",
"cornflower",
"cornhusk",
"cornhusker",
"cornhusking",
"cornice",
"cornish",
"cornishman",
"cornishwoman",
"cornmeal",
"cornpone",
"cornsilk",
"cornsmut",
"cornstalk",
"cornstarch",
"cornu",
"cornucopia",
"cornus",
"cornwall",
"cornwallis",
"corokia",
"corolla",
"corollary",
"corona",
"coronach",
"coronal",
"coronary",
"coronation",
"coroner",
"coronet",
"coronilla",
"coronion",
"coropuna",
"corot",
"corozo",
"corp",
"corporal",
"corporality",
"corporation",
"corporatism",
"corporatist",
"corporeality",
"corposant",
"corps",
"corpse",
"corpulence",
"corpulency",
"corpus",
"corpuscle",
"corral",
"corrasion",
"correction",
"corrections",
"correctitude",
"corrective",
"correctness",
"correggio",
"corregidor",
"correlate",
"correlation",
"correlative",
"correlativity",
"correspondence",
"correspondent",
"corrida",
"corridor",
"corrie",
"corrigenda",
"corrigendum",
"corroboration",
"corrodentia",
"corroding",
"corrosion",
"corrosive",
"corrugation",
"corruptibility",
"corruption",
"corruptness",
"corsage",
"corsair",
"corse",
"corselet",
"corset",
"corsica",
"corslet",
"cortaderia",
"cortef",
"cortege",
"cortes",
"cortex",
"cortez",
"corticium",
"corticoid",
"corticosteroid",
"corticosterone",
"corticotrophin",
"corticotropin",
"cortina",
"cortinariaceae",
"cortinarius",
"cortisol",
"cortisone",
"cortland",
"corundom",
"corundum",
"coruscation",
"corvee",
"corvette",
"corvidae",
"corvus",
"coryanthes",
"corydalidae",
"corydalis",
"corydalus",
"corylaceae",
"corylopsis",
"corylus",
"corymb",
"corynebacterium",
"corypha",
"coryphaenidae",
"coryphantha",
"corythosaur",
"corythosaurus",
"coryza",
"coscoroba",
"cosec",
"cosecant",
"cosh",
"cosignatory",
"cosigner",
"cosine",
"cosiness",
"cosmea",
"cosmetic",
"cosmetician",
"cosmetologist",
"cosmetology",
"cosmid",
"cosmocampus",
"cosmogeny",
"cosmogony",
"cosmographer",
"cosmographist",
"cosmography",
"cosmolatry",
"cosmologist",
"cosmology",
"cosmonaut",
"cosmopolitan",
"cosmopolite",
"cosmos",
"cosmotron",
"coss",
"cossack",
"cost",
"costa",
"costalgia",
"costanoan",
"costermonger",
"costia",
"costiasis",
"costing",
"costliness",
"costmary",
"costochondritis",
"costs",
"costume",
"costumer",
"costumier",
"costusroot",
"cosy",
"cotacachi",
"cotan",
"cotangent",
"cote",
"cotenant",
"coterie",
"cotilion",
"cotillion",
"cotinga",
"cotingidae",
"cotinus",
"cotoneaster",
"cotonou",
"cotopaxi",
"cotswold",
"cotswolds",
"cottage",
"cottager",
"cottar",
"cotter",
"cottidae",
"cottier",
"cotton",
"cottonmouth",
"cottonseed",
"cottontail",
"cottonweed",
"cottonwick",
"cottonwood",
"cottus",
"cotula",
"coturnix",
"cotyledon",
"coucal",
"couch",
"couchette",
"coue",
"cougar",
"cough",
"coughing",
"coulisse",
"coulomb",
"coulter",
"coumadin",
"coumarone",
"coumarouna",
"council",
"councillor",
"councillorship",
"councilman",
"councilorship",
"councilwoman",
"counsel",
"counseling",
"counselling",
"counsellor",
"counsellorship",
"counselor",
"counselorship",
"count",
"countdown",
"countenance",
"counter",
"counteraction",
"counterargument",
"counterattack",
"counterbalance",
"counterblast",
"counterblow",
"counterbore",
"countercharge",
"countercheck",
"counterclaim",
"countercoup",
"counterculture",
"countercurrent",
"counterexample",
"counterfeit",
"counterfeiter",
"counterfire",
"counterfoil",
"counterglow",
"counterirritant",
"counterman",
"countermand",
"countermarch",
"countermeasure",
"countermine",
"countermove",
"counteroffer",
"counterpane",
"counterpart",
"counterperson",
"counterplan",
"counterplay",
"counterplea",
"counterplot",
"counterpoint",
"counterpoise",
"counterpoison",
"counterproposal",
"counterpunch",
"countershot",
"countersign",
"countersink",
"counterspy",
"counterstain",
"countersuit",
"countertenor",
"countertop",
"counterweight",
"counterwoman",
"countess",
"counting",
"countinghouse",
"countlessness",
"country",
"countryfolk",
"countryman",
"countryseat",
"countryside",
"countrywoman",
"county",
"coup",
"coupe",
"couperin",
"couple",
"coupler",
"couplet",
"coupling",
"coupon",
"courage",
"courageousness",
"courante",
"courbaril",
"courbet",
"courgette",
"courier",
"courlan",
"course",
"courser",
"coursework",
"coursing",
"court",
"courtelle",
"courtesan",
"courtesy",
"courthouse",
"courtier",
"courting",
"courtliness",
"courtroom",
"courtship",
"courtyard",
"couscous",
"cousin",
"cousteau",
"couth",
"couture",
"couturier",
"couvade",
"couverture",
"covalence",
"covalency",
"covariance",
"covariation",
"cove",
"coven",
"covenant",
"coventry",
"cover",
"coverage",
"coverall",
"covering",
"coverlet",
"covert",
"covertness",
"covetousness",
"covey",
"coville",
"cowage",
"coward",
"cowardice",
"cowardliness",
"cowbarn",
"cowbell",
"cowberry",
"cowbird",
"cowboy",
"cowcatcher",
"cowfish",
"cowgirl",
"cowhand",
"cowherb",
"cowherd",
"cowhide",
"cowhouse",
"cowl",
"cowlick",
"cowling",
"cowman",
"cowpea",
"cowpens",
"cowper",
"cowpie",
"cowpoke",
"cowpox",
"cowpuncher",
"cowrie",
"cowry",
"cows",
"cowshed",
"cowskin",
"cowslip",
"cowtown",
"coxa",
"coxcomb",
"coxsackievirus",
"coxswain",
"coydog",
"coyness",
"coyol",
"coyote",
"coypu",
"cozenage",
"coziness",
"cozy",
"crab",
"crabapple",
"crabbedness",
"crabbiness",
"crabgrass",
"crabmeat",
"crabs",
"cracidae",
"crack",
"crackdown",
"cracker",
"crackerberry",
"crackerjack",
"cracking",
"crackle",
"crackleware",
"crackling",
"cracklings",
"crackpot",
"cracksman",
"cracow",
"cracticidae",
"cracticus",
"cradle",
"cradlesong",
"craft",
"crafter",
"craftiness",
"craftsman",
"craftsmanship",
"crag",
"cragsman",
"craigie",
"crake",
"crambe",
"crammer",
"cramp",
"crampbark",
"crampfish",
"crampon",
"crampoon",
"cran",
"cranberry",
"crane",
"cranesbill",
"crangon",
"crangonidae",
"craniata",
"craniate",
"craniologist",
"craniology",
"craniometer",
"craniometry",
"craniotomy",
"cranium",
"crank",
"crankcase",
"crankiness",
"crankshaft",
"cranny",
"crap",
"crapaud",
"crape",
"crapette",
"crapper",
"crappie",
"craps",
"crapshoot",
"crapshooter",
"crapulence",
"crash",
"crasher",
"craspedia",
"crassitude",
"crassness",
"crassostrea",
"crassula",
"crassulaceae",
"crataegus",
"crate",
"crateful",
"crater",
"crateva",
"craton",
"cravat",
"craven",
"cravenness",
"craving",
"craw",
"crawdad",
"crawdaddy",
"crawfish",
"crawford",
"crawl",
"crawler",
"crawling",
"crawlspace",
"crax",
"crayfish",
"crayon",
"craze",
"craziness",
"crazy",
"crazyweed",
"creak",
"creaking",
"cream",
"creamcups",
"creamer",
"creamery",
"creaminess",
"crease",
"creashak",
"creatin",
"creatine",
"creation",
"creationism",
"creativeness",
"creativity",
"creator",
"creature",
"creche",
"crecy",
"cred",
"credence",
"credendum",
"credential",
"credentials",
"credenza",
"credibility",
"credibleness",
"credit",
"creditor",
"credits",
"credo",
"credulity",
"credulousness",
"cree",
"creed",
"creek",
"creel",
"creep",
"creeper",
"creepiness",
"creeping",
"creeps",
"creese",
"cremains",
"cremation",
"crematorium",
"crematory",
"cremona",
"crenation",
"crenature",
"crenel",
"crenelation",
"crenellation",
"crenelle",
"creole",
"creon",
"creosol",
"creosote",
"crepe",
"crepis",
"crepitation",
"crepuscle",
"crepuscule",
"crescendo",
"crescent",
"crescentia",
"cresol",
"cress",
"crest",
"cretaceous",
"cretan",
"crete",
"cretin",
"cretinism",
"cretonne",
"crevasse",
"crevice",
"crew",
"crewelwork",
"crewet",
"crewman",
"crex",
"crib",
"cribbage",
"cricetidae",
"cricetus",
"crichton",
"crick",
"cricket",
"cricketer",
"crier",
"crime",
"crimea",
"criminal",
"criminalisation",
"criminalism",
"criminality",
"criminalization",
"criminalness",
"criminologist",
"criminology",
"crimp",
"crimper",
"crimson",
"cringle",
"crinion",
"crinkle",
"crinkleroot",
"crinoid",
"crinoidea",
"crinoline",
"criollo",
"cripple",
"crisis",
"crisp",
"crispin",
"crispiness",
"crispness",
"crisscross",
"cristal",
"cristobalite",
"crit",
"criterion",
"criterium",
"crith",
"critic",
"criticality",
"criticalness",
"criticism",
"critique",
"critter",
"crius",
"crixivan",
"croak",
"croaker",
"croaking",
"croat",
"croatia",
"croatian",
"crocethia",
"crochet",
"crocheting",
"crock",
"crockery",
"crocket",
"crockett",
"crocodile",
"crocodilia",
"crocodilian",
"crocodilus",
"crocodylia",
"crocodylidae",
"crocodylus",
"crocolite",
"crocus",
"crocuta",
"croesus",
"croft",
"crofter",
"crohn",
"croissant",
"cromlech",
"cromorne",
"cromwell",
"cronartium",
"crone",
"cronus",
"crony",
"cronyism",
"cronyn",
"crook",
"crookback",
"crookedness",
"crookes",
"crookneck",
"crooner",
"crooning",
"crop",
"cropper",
"croquet",
"croquette",
"crore",
"crosby",
"crosier",
"cross",
"crossbar",
"crossbeam",
"crossbench",
"crossbencher",
"crossbill",
"crossbones",
"crossbow",
"crossbreed",
"crossbreeding",
"crosscheck",
"crosscurrent",
"crosscut",
"crosse",
"crossfire",
"crosshairs",
"crosshatch",
"crosshead",
"crossheading",
"crossing",
"crossjack",
"crossness",
"crossopterygian",
"crossopterygii",
"crossover",
"crosspatch",
"crosspiece",
"crossroad",
"crossroads",
"crosstalk",
"crosstie",
"crosswalk",
"crossway",
"crosswind",
"crossword",
"crotal",
"crotalaria",
"crotalidae",
"crotalus",
"crotaphion",
"crotaphytus",
"crotch",
"crotchet",
"crotchetiness",
"croton",
"crotonbug",
"crotophaga",
"crottal",
"crottle",
"crouch",
"croup",
"croupe",
"croupier",
"crouse",
"crouton",
"crow",
"crowbait",
"crowbar",
"crowberry",
"crowd",
"crowding",
"crowfoot",
"crowing",
"crown",
"crownbeard",
"crownwork",
"crozier",
"cruciality",
"crucible",
"crucifer",
"cruciferae",
"crucifix",
"crucifixion",
"crud",
"crude",
"crudeness",
"crudites",
"crudity",
"cruelness",
"cruelty",
"cruet",
"cruise",
"cruiser",
"cruiserweight",
"cruller",
"crumb",
"crumbliness",
"crumhorn",
"crumpet",
"crunch",
"crupper",
"crus",
"crusade",
"crusader",
"cruse",
"crush",
"crusher",
"crushing",
"crust",
"crustacea",
"crustacean",
"crutch",
"crux",
"cryaesthesia",
"crybaby",
"cryesthesia",
"crying",
"cryoanaesthesia",
"cryoanesthesia",
"cryobiology",
"cryocautery",
"cryogen",
"cryogenics",
"cryogeny",
"cryolite",
"cryometer",
"cryonics",
"cryopathy",
"cryophobia",
"cryoscope",
"cryostat",
"cryosurgery",
"crypt",
"cryptacanthodes",
"cryptanalysis",
"cryptanalyst",
"cryptanalytics",
"cryptobiosis",
"cryptobranchus",
"cryptocercidae",
"cryptocercus",
"cryptococcosis",
"cryptocoryne",
"cryptogam",
"cryptogamia",
"cryptogram",
"cryptogramma",
"cryptograph",
"cryptographer",
"cryptography",
"cryptologist",
"cryptology",
"cryptomeria",
"cryptomonad",
"cryptophyceae",
"cryptophyta",
"cryptophyte",
"cryptoprocta",
"cryptorchidism",
"cryptorchidy",
"cryptorchism",
"cryptotermes",
"cryptotis",
"crystal",
"crystallisation",
"crystallite",
"crystallization",
"crystallizing",
"crystallography",
"csis",
"ctene",
"ctenidium",
"ctenizidae",
"ctenocephalides",
"ctenocephalus",
"ctenophora",
"ctenophore",
"cuba",
"cuban",
"cubby",
"cubbyhole",
"cube",
"cubeb",
"cubicity",
"cubicle",
"cubism",
"cubist",
"cubit",
"cubitiere",
"cubitus",
"cuboid",
"cuckold",
"cuckoldom",
"cuckoldry",
"cuckoo",
"cuckooflower",
"cuckoopint",
"cuculidae",
"cuculiformes",
"cuculus",
"cucumber",
"cucumis",
"cucurbit",
"cucurbita",
"cucurbitaceae",
"cudbear",
"cuddle",
"cuddling",
"cuddy",
"cudgel",
"cudweed",
"cuff",
"cufflink",
"cuirass",
"cuirassier",
"cuisine",
"cuisse",
"cuke",
"culbertson",
"culcita",
"culdoscope",
"culdoscopy",
"culebra",
"culex",
"culiacan",
"culicidae",
"cull",
"cullender",
"cullis",
"culm",
"culmination",
"culotte",
"culpability",
"culpableness",
"culprit",
"cult",
"cultism",
"cultist",
"cultivar",
"cultivation",
"cultivator",
"culturati",
"culture",
"cultus",
"culverin",
"culvert",
"cumana",
"cumarone",
"cumberland",
"cumbersomeness",
"cumbria",
"cumfrey",
"cumin",
"cuminum",
"cummerbund",
"cummings",
"cumquat",
"cumulation",
"cumulonimbus",
"cumulus",
"cunaxa",
"cunctation",
"cunctator",
"cuneiform",
"cuneus",
"cuniculus",
"cunner",
"cunnilinctus",
"cunnilingus",
"cunning",
"cunningham",
"cunoniaceae",
"cunt",
"cuon",
"cupbearer",
"cupboard",
"cupcake",
"cupel",
"cupflower",
"cupful",
"cupid",
"cupidity",
"cupola",
"cuppa",
"cupper",
"cupping",
"cupressaceae",
"cupressus",
"cuprimine",
"cuprite",
"cupronickel",
"cupule",
"cuquenan",
"curability",
"curableness",
"curacao",
"curacoa",
"curacy",
"curandera",
"curandero",
"curare",
"curassow",
"curate",
"curative",
"curator",
"curatorship",
"curb",
"curbing",
"curbside",
"curbstone",
"curculionidae",
"curcuma",
"curd",
"curdling",
"cure",
"curet",
"curettage",
"curette",
"curettement",
"curfew",
"curia",
"curie",
"curietherapy",
"curing",
"curio",
"curiosa",
"curiosity",
"curiousness",
"curitiba",
"curium",
"curl",
"curler",
"curlew",
"curlicue",
"curliness",
"curling",
"curmudgeon",
"currajong",
"currant",
"currawong",
"currency",
"current",
"currentness",
"curriculum",
"currier",
"curry",
"currycomb",
"curse",
"cursive",
"cursor",
"cursorius",
"curtailment",
"curtain",
"curtilage",
"curtis",
"curtisia",
"curtiss",
"curtness",
"curtsey",
"curtsy",
"curvaceousness",
"curvature",
"curve",
"curvet",
"cusco",
"cuscus",
"cuscuta",
"cushat",
"cushaw",
"cushing",
"cushion",
"cushioning",
"cushitic",
"cusk",
"cusp",
"cuspid",
"cuspidation",
"cuspidor",
"cuss",
"cussedness",
"custard",
"custer",
"custodian",
"custodianship",
"custody",
"custom",
"customer",
"customhouse",
"customs",
"customshouse",
"cutaway",
"cutback",
"cutch",
"cuteness",
"cuterebra",
"cuterebridae",
"cuticle",
"cuticula",
"cutin",
"cutis",
"cutlas",
"cutlass",
"cutlassfish",
"cutler",
"cutlery",
"cutlet",
"cutoff",
"cutout",
"cutpurse",
"cutter",
"cutthroat",
"cutting",
"cuttle",
"cuttlefish",
"cutwork",
"cutworm",
"cuvier",
"cuzco",
"cyamopsis",
"cyamus",
"cyan",
"cyanamid",
"cyanamide",
"cyanide",
"cyanite",
"cyanobacteria",
"cyanocitta",
"cyanocobalamin",
"cyanogen",
"cyanohydrin",
"cyanophyceae",
"cyanophyta",
"cyanosis",
"cyanuramide",
"cyathea",
"cyatheaceae",
"cybele",
"cyberart",
"cybercafe",
"cybercrime",
"cyberculture",
"cybernation",
"cybernaut",
"cybernetics",
"cyberphobia",
"cyberpunk",
"cybersex",
"cyberspace",
"cyberwar",
"cyborg",
"cycad",
"cycadaceae",
"cycadales",
"cycadofilicales",
"cycadophyta",
"cycadophytina",
"cycadopsida",
"cycas",
"cyclades",
"cyclamen",
"cycle",
"cyclicity",
"cycling",
"cycliophora",
"cyclist",
"cyclobenzaprine",
"cyclohexanol",
"cycloid",
"cycloloma",
"cyclone",
"cyclooxygenase",
"cyclopaedia",
"cyclopedia",
"cyclopes",
"cyclophorus",
"cyclopia",
"cyclopropane",
"cyclops",
"cyclopteridae",
"cyclopterus",
"cyclorama",
"cycloserine",
"cyclosis",
"cyclosorus",
"cyclosporeae",
"cyclostomata",
"cyclostome",
"cyclostyle",
"cyclothymia",
"cyclotron",
"cycnoches",
"cyder",
"cydippea",
"cydippida",
"cydippidea",
"cydonia",
"cygnet",
"cygnus",
"cylinder",
"cylindricality",
"cylindricalness",
"cylix",
"cyma",
"cymatiidae",
"cymatium",
"cymbal",
"cymbalist",
"cymbid",
"cymbidium",
"cyme",
"cymene",
"cymling",
"cymograph",
"cymric",
"cymru",
"cymry",
"cymule",
"cynancum",
"cynara",
"cynewulf",
"cynic",
"cynicism",
"cynipidae",
"cynips",
"cynocephalidae",
"cynocephalus",
"cynodon",
"cynodont",
"cynodontia",
"cynoglossidae",
"cynoglossum",
"cynomys",
"cynophobia",
"cynopterus",
"cynoscephalae",
"cynoscion",
"cynosure",
"cynthia",
"cynwulf",
"cyon",
"cyperaceae",
"cyperus",
"cypher",
"cyphomandra",
"cypraea",
"cypraeidae",
"cypre",
"cypress",
"cyprian",
"cyprinid",
"cyprinidae",
"cypriniformes",
"cyprinodont",
"cyprinodontidae",
"cyprinus",
"cypriot",
"cypriote",
"cypripedia",
"cypripedium",
"cyproheptadine",
"cyprus",
"cyril",
"cyrilla",
"cyrilliaceae",
"cyrillic",
"cyrtomium",
"cyrus",
"cyst",
"cysteine",
"cystine",
"cystitis",
"cystocele",
"cystolith",
"cystoparalysis",
"cystophora",
"cystoplegia",
"cystopteris",
"cytherea",
"cytidine",
"cytisus",
"cytochrome",
"cytogenesis",
"cytogeneticist",
"cytogenetics",
"cytogeny",
"cytokine",
"cytokinesis",
"cytokinin",
"cytol",
"cytologist",
"cytology",
"cytolysin",
"cytolysis",
"cytomegalovirus",
"cytomembrane",
"cytopenia",
"cytophotometer",
"cytophotometry",
"cytoplasm",
"cytoplast",
"cytosine",
"cytoskeleton",
"cytosmear",
"cytosol",
"cytostome",
"cytotoxicity",
"cytotoxin",
"czar",
"czarina",
"czaritza",
"czech",
"czechoslovak",
"czechoslovakia",
"czechoslovakian",
"czerny",
"czestochowa",
"daba",
"dabbler",
"dabchick",
"daboecia",
"dacca",
"dace",
"dacelo",
"dacha",
"dachau",
"dachshund",
"dachsie",
"dacite",
"dacninae",
"dacoit",
"dacoity",
"dacron",
"dacrycarpus",
"dacrydium",
"dacrymyces",
"dacrymycetaceae",
"dacryocyst",
"dacryocystitis",
"dacryon",
"dactyl",
"dactylis",
"dactyloctenium",
"dactylomegaly",
"dactylopiidae",
"dactylopius",
"dactylopteridae",
"dactylopterus",
"dactylorhiza",
"dactyloscopidae",
"dada",
"dadaism",
"daddy",
"dado",
"daedal",
"daedalus",
"daemon",
"daffo",
"daffodil",
"dafla",
"daftness",
"dagame",
"dagan",
"dagda",
"dagestani",
"dagga",
"dagger",
"daggerboard",
"dago",
"dagon",
"daguerre",
"daguerreotype",
"dahl",
"dahlia",
"dahna",
"dahomey",
"daikon",
"dail",
"daily",
"daimler",
"daimon",
"daintiness",
"dainty",
"daiquiri",
"dairen",
"dairy",
"dairying",
"dairymaid",
"dairyman",
"dais",
"daishiki",
"daisy",
"daisybush",
"dakar",
"dakoit",
"dakoity",
"dakota",
"dalasi",
"dalbergia",
"dale",
"dalea",
"dalesman",
"daleth",
"dali",
"dalian",
"dallas",
"dalliance",
"dallier",
"dallisgrass",
"dalmane",
"dalmatia",
"dalmatian",
"dalo",
"dalton",
"daltonism",
"dama",
"damage",
"damages",
"damaliscus",
"damar",
"damascene",
"damascus",
"damask",
"dame",
"damgalnunna",
"daminozide",
"damkina",
"dammar",
"damn",
"damnation",
"damned",
"damocles",
"damoiselle",
"damon",
"damosel",
"damourite",
"damozel",
"damp",
"dampener",
"dampening",
"damper",
"dampness",
"damsel",
"damselfish",
"damselfly",
"damson",
"dana",
"danaea",
"danaid",
"danaidae",
"danau",
"danaus",
"dance",
"dancer",
"dancing",
"dandelion",
"dander",
"dandruff",
"dandy",
"dandyism",
"dane",
"danewort",
"dangaleat",
"danger",
"dangerousness",
"dangla",
"dangleberry",
"dangling",
"daniel",
"danish",
"dankness",
"danmark",
"danseur",
"danseuse",
"dante",
"danton",
"danu",
"danube",
"danzig",
"daoism",
"daphne",
"daphnia",
"dapperness",
"dapple",
"dapsang",
"dapsone",
"daraf",
"dard",
"dardan",
"dardanelles",
"dardanian",
"dardanus",
"dardic",
"dare",
"daredevil",
"daredevilry",
"daredeviltry",
"darfur",
"dari",
"daricon",
"daring",
"darjeeling",
"dark",
"darkening",
"darkness",
"darkroom",
"darling",
"darlingtonia",
"darmera",
"darmstadtium",
"darn",
"darnel",
"darner",
"darning",
"darpa",
"darrow",
"darsana",
"dart",
"dartboard",
"darter",
"dartmouth",
"darts",
"darvon",
"darwin",
"darwinian",
"darwinism",
"dash",
"dashboard",
"dasheen",
"dashiki",
"dassie",
"dastard",
"dastardliness",
"dasyatidae",
"dasyatis",
"dasymeter",
"dasypodidae",
"dasyprocta",
"dasyproctidae",
"dasypus",
"dasyure",
"dasyurid",
"dasyuridae",
"dasyurus",
"data",
"database",
"date",
"dateline",
"dating",
"dative",
"datril",
"datum",
"datura",
"daub",
"daubentonia",
"daubentoniidae",
"dauber",
"daubing",
"daucus",
"daugavpils",
"daughter",
"daumier",
"dauntlessness",
"dauphin",
"davallia",
"davalliaceae",
"davenport",
"david",
"daviesia",
"davis",
"davit",
"davy",
"davys",
"dawah",
"dawdler",
"dawdling",
"dawes",
"dawn",
"dawning",
"dawson",
"dayan",
"daybed",
"daybook",
"dayboy",
"daybreak",
"daycare",
"daydream",
"daydreamer",
"daydreaming",
"dayflower",
"dayfly",
"daygirl",
"daylight",
"daylily",
"daypro",
"days",
"dayspring",
"daystar",
"daytime",
"dayton",
"daze",
"dazzle",
"dbms",
"dccp",
"deacon",
"deaconess",
"deactivation",
"dead",
"deadbeat",
"deadbolt",
"deadening",
"deadeye",
"deadhead",
"deadlight",
"deadline",
"deadliness",
"deadlock",
"deadness",
"deadwood",
"deaf",
"deafness",
"deal",
"dealer",
"dealership",
"dealfish",
"dealignment",
"dealing",
"dealings",
"deamination",
"deaminization",
"dean",
"deanery",
"deanship",
"dear",
"dearest",
"dearie",
"dearness",
"dearth",
"deary",
"death",
"deathbed",
"deathblow",
"deathrate",
"deathtrap",
"deathwatch",
"debacle",
"debarkation",
"debarment",
"debasement",
"debaser",
"debate",
"debater",
"debauch",
"debauchee",
"debaucher",
"debauchery",
"debenture",
"debilitation",
"debility",
"debit",
"debitor",
"debridement",
"debriefing",
"debris",
"debs",
"debt",
"debtor",
"debugger",
"debunking",
"debussy",
"debut",
"debutante",
"decade",
"decadence",
"decadency",
"decadent",
"decadron",
"decaf",
"decagon",
"decagram",
"decahedron",
"decal",
"decalcification",
"decalcomania",
"decalescence",
"decaliter",
"decalitre",
"decalogue",
"decameter",
"decametre",
"decampment",
"decantation",
"decanter",
"decapitation",
"decapod",
"decapoda",
"decapterus",
"decarboxylase",
"decarboxylation",
"decasyllable",
"decathlon",
"decatur",
"decay",
"decease",
"deceased",
"decedent",
"deceit",
"deceitfulness",
"deceiver",
"deceleration",
"december",
"decency",
"decennary",
"decennium",
"decentalisation",
"deception",
"deceptiveness",
"decibel",
"deciding",
"decidua",
"decigram",
"decile",
"deciliter",
"decilitre",
"decimal",
"decimalisation",
"decimalization",
"decimation",
"decimeter",
"decimetre",
"decipherer",
"decipherment",
"decision",
"decisiveness",
"decius",
"deck",
"decker",
"deckhand",
"deckle",
"declamation",
"declaration",
"declarative",
"declarer",
"declension",
"declination",
"decline",
"declinometer",
"declivity",
"declomycin",
"deco",
"decoagulant",
"decoction",
"decoder",
"decoding",
"decolletage",
"decolonisation",
"decolonization",
"decomposition",
"decompressing",
"decompression",
"decongestant",
"deconstruction",
"decontamination",
"decor",
"decoration",
"decorativeness",
"decorator",
"decorousness",
"decortication",
"decorum",
"decoupage",
"decoy",
"decrease",
"decree",
"decrement",
"decrepitation",
"decrepitude",
"decrescendo",
"decryption",
"decubitus",
"decumaria",
"decumary",
"decussation",
"dedication",
"deductible",
"deduction",
"deed",
"deedbox",
"deeds",
"deep",
"deepening",
"deepfreeze",
"deepness",
"deer",
"deerberry",
"deere",
"deerhound",
"deerskin",
"deerstalker",
"deerstalking",
"defacement",
"defalcation",
"defalcator",
"defamation",
"defamer",
"default",
"defaulter",
"defeat",
"defeated",
"defeatism",
"defeatist",
"defecation",
"defecator",
"defect",
"defection",
"defectiveness",
"defector",
"defence",
"defencelessness",
"defendant",
"defender",
"defenestration",
"defense",
"defenselessness",
"defensibility",
"defensive",
"defensiveness",
"deference",
"deferment",
"deferral",
"defervescence",
"defiance",
"defibrillation",
"defibrillator",
"deficiency",
"deficit",
"defilade",
"defile",
"defilement",
"defiler",
"defining",
"definiteness",
"definition",
"deflagration",
"deflation",
"deflator",
"deflection",
"deflector",
"deflexion",
"defloration",
"defoe",
"defoliant",
"defoliation",
"defoliator",
"deforestation",
"deformation",
"deformity",
"defrauder",
"defrayal",
"defrayment",
"defroster",
"deftness",
"defunctness",
"defusing",
"degas",
"degaussing",
"degeneracy",
"degenerate",
"degeneration",
"deglutition",
"degradation",
"degrader",
"degree",
"degustation",
"dehiscence",
"dehumanisation",
"dehumanization",
"dehumidifier",
"dehydration",
"dehydroretinol",
"deicer",
"deictic",
"deification",
"deimos",
"deinocheirus",
"deinonychus",
"deipnosophist",
"deism",
"deist",
"deity",
"deixis",
"dejectedness",
"dejection",
"dejeuner",
"dekagram",
"dekaliter",
"dekalitre",
"dekameter",
"dekametre",
"dekker",
"dekko",
"delacroix",
"delairea",
"delavirdine",
"delaware",
"delawarean",
"delawarian",
"delay",
"delayer",
"delbruck",
"delectability",
"delectation",
"delegacy",
"delegate",
"delegating",
"delegation",
"deletion",
"delf",
"delft",
"delhi",
"deli",
"deliberateness",
"deliberation",
"delibes",
"delicacy",
"delicatessen",
"delichon",
"delicious",
"deliciousness",
"delight",
"delilah",
"delimitation",
"delineation",
"delinquency",
"delinquent",
"deliquium",
"delirium",
"delius",
"deliverable",
"deliverance",
"deliverer",
"delivery",
"deliveryman",
"dell",
"delonix",
"delorme",
"delphi",
"delphinapterus",
"delphinidae",
"delphinium",
"delphinus",
"delta",
"deltasone",
"deltoid",
"deluge",
"delusion",
"demagnetisation",
"demagnetization",
"demagog",
"demagogue",
"demagoguery",
"demagogy",
"demand",
"demander",
"demantoid",
"demarcation",
"demarche",
"dematiaceae",
"demavend",
"demeanor",
"demeanour",
"dementedness",
"dementia",
"demerara",
"demerit",
"demerol",
"demesne",
"demeter",
"demetrius",
"demiglace",
"demigod",
"demijohn",
"demille",
"demimondaine",
"demimonde",
"demise",
"demisemiquaver",
"demister",
"demitasse",
"demiurge",
"demo",
"demobilisation",
"demobilization",
"democracy",
"democrat",
"democratisation",
"democratization",
"democritus",
"demodulation",
"demodulator",
"demogorgon",
"demographer",
"demographic",
"demographist",
"demography",
"demoiselle",
"demolishing",
"demolition",
"demon",
"demonetisation",
"demonetization",
"demoniac",
"demonisation",
"demonism",
"demonization",
"demonolatry",
"demonstrability",
"demonstration",
"demonstrative",
"demonstrator",
"demoralisation",
"demoralization",
"demosthenes",
"demotic",
"demotion",
"dempsey",
"demulcent",
"demulen",
"demur",
"demureness",
"demurrage",
"demurral",
"demurrer",
"demyelination",
"denali",
"denaturant",
"denazification",
"dendranthema",
"dendraspis",
"dendrite",
"dendroaspis",
"dendrobium",
"dendrocalamus",
"dendrocolaptes",
"dendroctonus",
"dendroica",
"dendrolagus",
"dendrology",
"dendromecon",
"deneb",
"denebola",
"dengue",
"denial",
"denier",
"denigration",
"denim",
"denisonia",
"denizen",
"denmark",
"dennstaedtia",
"denomination",
"denominator",
"denotation",
"denotatum",
"denouement",
"denouncement",
"denseness",
"densification",
"densimeter",
"densitometer",
"densitometry",
"density",
"dent",
"dental",
"dentaria",
"denticle",
"dentifrice",
"dentin",
"dentine",
"dentist",
"dentistry",
"dentition",
"denture",
"denturist",
"denudation",
"denunciation",
"denver",
"deodar",
"deodorant",
"deodourant",
"deossification",
"deoxyadenosine",
"deoxycytidine",
"deoxyephedrine",
"deoxyguanosine",
"deoxyribose",
"deoxythymidine",
"depardieu",
"deparia",
"departed",
"departer",
"department",
"departure",
"dependability",
"dependableness",
"dependance",
"dependant",
"dependence",
"dependency",
"dependent",
"depicting",
"depiction",
"depigmentation",
"depilation",
"depilator",
"depilatory",
"depletion",
"deployment",
"depokene",
"depolarisation",
"depolarization",
"deponent",
"depopulation",
"deportation",
"deportee",
"deportment",
"deposer",
"deposit",
"depositary",
"deposition",
"depositor",
"depository",
"depot",
"depravation",
"depravity",
"deprecation",
"depreciation",
"depreciator",
"depredation",
"depressant",
"depression",
"depressive",
"depressor",
"deprivation",
"depth",
"depths",
"deputation",
"deputy",
"deracination",
"derailment",
"derain",
"derangement",
"derby",
"deregulating",
"deregulation",
"derelict",
"dereliction",
"derision",
"derivation",
"derivative",
"deriving",
"derma",
"dermabrasion",
"dermacentor",
"dermaptera",
"dermatitis",
"dermatobia",
"dermatoglyphic",
"dermatoglyphics",
"dermatologist",
"dermatology",
"dermatome",
"dermatomycosis",
"dermatomyositis",
"dermatophytosis",
"dermatosis",
"dermestidae",
"dermis",
"dermochelyidae",
"dermochelys",
"dermoptera",
"derogation",
"derrick",
"derrida",
"derriere",
"derringer",
"derris",
"derv",
"dervish",
"desalination",
"desalinisation",
"desalinization",
"descant",
"descartes",
"descendant",
"descendants",
"descendent",
"descender",
"descensus",
"descent",
"description",
"descriptivism",
"descriptor",
"descurainia",
"desecration",
"desegregation",
"desensitisation",
"desensitization",
"desert",
"deserter",
"desertification",
"desertion",
"deservingness",
"deshabille",
"desiccant",
"desiccation",
"desideratum",
"design",
"designation",
"designatum",
"designer",
"designing",
"desipramine",
"desirability",
"desirableness",
"desire",
"desk",
"deskman",
"desktop",
"desmanthus",
"desmid",
"desmidiaceae",
"desmidium",
"desmodium",
"desmodontidae",
"desmodus",
"desmograthus",
"desolation",
"desorption",
"despair",
"despatch",
"desperado",
"desperate",
"desperation",
"despicability",
"despicableness",
"despisal",
"despising",
"despite",
"despoilation",
"despoiler",
"despoilment",
"despoina",
"despoliation",
"despondence",
"despondency",
"despot",
"despotism",
"desquamation",
"dessert",
"dessertspoon",
"dessertspoonful",
"dessiatine",
"destabilisation",
"destabilization",
"destalinisation",
"destalinization",
"destination",
"destiny",
"destitution",
"destroyer",
"destructibility",
"destruction",
"destructiveness",
"desuetude",
"desynchronizing",
"desyrel",
"detachment",
"detail",
"detailing",
"details",
"detainee",
"detainment",
"detecting",
"detection",
"detective",
"detector",
"detent",
"detente",
"detention",
"detergence",
"detergency",
"detergent",
"deterioration",
"determent",
"determinant",
"determinateness",
"determination",
"determinative",
"determiner",
"determinism",
"determinist",
"deterrence",
"deterrent",
"detestation",
"dethronement",
"detonation",
"detonator",
"detour",
"detox",
"detoxification",
"detraction",
"detractor",
"detribalisation",
"detribalization",
"detriment",
"detrition",
"detritus",
"detroit",
"detumescence",
"deuce",
"deuteranopia",
"deuterium",
"deuteromycetes",
"deuteromycota",
"deuteromycotina",
"deuteron",
"deuteronomy",
"deutschland",
"deutschmark",
"deutzia",
"devaluation",
"devanagari",
"devastation",
"developer",
"developing",
"development",
"devi",
"deviance",
"deviant",
"deviate",
"deviation",
"deviationism",
"deviationist",
"device",
"devices",
"devil",
"devilfish",
"devilment",
"devilry",
"deviltry",
"devilwood",
"deviousness",
"devisal",
"devise",
"devisee",
"deviser",
"devising",
"devisor",
"devitalisation",
"devitalization",
"devoir",
"devolution",
"devolvement",
"devon",
"devonian",
"devonshire",
"devotedness",
"devotee",
"devotion",
"devotional",
"devourer",
"devoutness",
"devries",
"dewar",
"dewberry",
"dewdrop",
"dewey",
"dewlap",
"dexamethasone",
"dexedrine",
"dexone",
"dexterity",
"dextrality",
"dextrin",
"dextrocardia",
"dextroglucose",
"dextrorotation",
"dextrose",
"dflp",
"dhahran",
"dhak",
"dhaka",
"dhal",
"dharma",
"dhaulagiri",
"dhava",
"dhawa",
"dhegiha",
"dhodhekanisos",
"dhole",
"dhoti",
"dhow",
"diabeta",
"diabetes",
"diabetic",
"diabolatry",
"diabolism",
"diabolist",
"diacalpa",
"diachrony",
"diacritic",
"diadem",
"diadophis",
"diaeresis",
"diaghilev",
"diaglyph",
"diagnosing",
"diagnosis",
"diagnostician",
"diagnostics",
"diagonal",
"diagonalisation",
"diagonalization",
"diagram",
"diagramming",
"diakinesis",
"dial",
"dialect",
"dialectic",
"dialectician",
"dialectics",
"dialectology",
"dialeurodes",
"dialog",
"dialogue",
"dialysis",
"dialyzer",
"diam",
"diamagnet",
"diamagnetism",
"diamante",
"diameter",
"diamine",
"diamond",
"diamondback",
"diana",
"dianthus",
"diapason",
"diapedesis",
"diapensia",
"diapensiaceae",
"diapensiales",
"diaper",
"diapheromera",
"diaphone",
"diaphoresis",
"diaphoretic",
"diaphragm",
"diaphysis",
"diapir",
"diapsid",
"diapsida",
"diarchy",
"diarist",
"diarrhea",
"diarrhoea",
"diarthrosis",
"diary",
"dias",
"diaspididae",
"diaspora",
"diastasis",
"diastema",
"diastole",
"diastrophism",
"diathermy",
"diathesis",
"diatom",
"diatomite",
"diatomophyceae",
"diatribe",
"diaz",
"diazepam",
"diazonium",
"diazoxide",
"dibber",
"dibble",
"dibbuk",
"dibrach",
"dibranch",
"dibranchia",
"dibranchiata",
"dibranchiate",
"dibs",
"dibucaine",
"dicamptodon",
"dicamptodontid",
"dice",
"dicentra",
"dicer",
"diceros",
"dichloride",
"dichloromethane",
"dichondra",
"dichotomisation",
"dichotomization",
"dichotomy",
"dichroism",
"dichromacy",
"dichromasy",
"dichromat",
"dichromate",
"dichromatism",
"dichromatopsia",
"dichromia",
"dick",
"dickens",
"dickey",
"dickeybird",
"dickhead",
"dickie",
"dickinson",
"dicksonia",
"dicksoniaceae",
"dicky",
"dickybird",
"dicloxacillin",
"dicot",
"dicotyledon",
"dicotyledonae",
"dicotyledones",
"dicoumarol",
"dicranaceae",
"dicranales",
"dicranopteris",
"dicranum",
"dicrostonyx",
"dictamnus",
"dictaphone",
"dictate",
"dictation",
"dictator",
"dictatorship",
"diction",
"dictionary",
"dictostylium",
"dictum",
"dictyophera",
"dictyoptera",
"dictyosome",
"dicumarol",
"dicynodont",
"dicynodontia",
"didacticism",
"didactics",
"didanosine",
"diddley",
"diddly",
"diddlyshit",
"diddlysquat",
"didelphidae",
"didelphis",
"dideoxycytosine",
"dideoxyinosine",
"diderot",
"didion",
"dido",
"didrikson",
"dieback",
"dieffenbachia",
"diegueno",
"diehard",
"dielectric",
"dielectrolysis",
"diemaker",
"diencephalon",
"dieresis",
"diervilla",
"diesel",
"diesinker",
"diesis",
"diestock",
"diestrum",
"diestrus",
"diet",
"dietary",
"dieter",
"dietetics",
"dietician",
"dieting",
"dietitian",
"dietrich",
"difference",
"differentia",
"differential",
"differentiation",
"differentiator",
"difficultness",
"difficulty",
"diffidence",
"difflugia",
"diffraction",
"diffuseness",
"diffuser",
"diffusion",
"diffusor",
"diflunisal",
"digenesis",
"digest",
"digester",
"digestibility",
"digestibleness",
"digestion",
"digestive",
"digger",
"digging",
"diggings",
"digit",
"digitalin",
"digitalis",
"digitalisation",
"digitalization",
"digitaria",
"digitigrade",
"digitisation",
"digitiser",
"digitization",
"digitizer",
"digitoxin",
"dignitary",
"dignity",
"digoxin",
"digram",
"digraph",
"digression",
"digs",
"dihybrid",
"dijon",
"dika",
"dike",
"dilantin",
"dilapidation",
"dilatation",
"dilater",
"dilation",
"dilator",
"dilatoriness",
"dilaudid",
"dildo",
"dilemma",
"dilettante",
"diligence",
"dill",
"dillenia",
"dilleniaceae",
"dilleniidae",
"dillydallier",
"diltiazem",
"diluent",
"dilutant",
"dilution",
"dimaggio",
"dimash",
"dime",
"dimenhydrinate",
"dimension",
"dimensionality",
"dimer",
"dimetane",
"dimetapp",
"dimetrodon",
"diminuendo",
"diminution",
"diminutive",
"diminutiveness",
"dimity",
"dimmer",
"dimness",
"dimocarpus",
"dimorphism",
"dimorphotheca",
"dimout",
"dimple",
"dimwit",
"dinar",
"dindymene",
"diner",
"dinero",
"dinesen",
"dinette",
"ding",
"dingbat",
"dinge",
"dinghy",
"dinginess",
"dingle",
"dingo",
"dining",
"dink",
"dinka",
"dinkey",
"dinky",
"dinner",
"dinnertime",
"dinnerware",
"dinoceras",
"dinocerata",
"dinocerate",
"dinoflagellata",
"dinoflagellate",
"dinornis",
"dinornithidae",
"dinosaur",
"dint",
"diocesan",
"diocese",
"diocletian",
"diode",
"diodon",
"diodontidae",
"diogenes",
"diol",
"diomedeidae",
"dionaea",
"dionysia",
"dionysius",
"dionysus",
"dioon",
"diophantus",
"diopter",
"dioptre",
"dior",
"diorama",
"diorite",
"dioscorea",
"dioscoreaceae",
"diospyros",
"diovan",
"dioxide",
"dioxin",
"diphenhydramine",
"diphtheria",
"diphthong",
"diphylla",
"dipladenia",
"diplegia",
"diplococcus",
"diplodocus",
"diploid",
"diploidy",
"diploma",
"diplomacy",
"diplomat",
"diplomate",
"diplomatist",
"diplopia",
"diplopoda",
"diplopterygium",
"diplotaxis",
"diplotene",
"dipnoi",
"dipodidae",
"dipodomys",
"dipogon",
"dipole",
"dipper",
"dippers",
"dipsacaceae",
"dipsacus",
"dipsomania",
"dipsomaniac",
"dipsosaurus",
"dipstick",
"diptera",
"dipteran",
"dipterocarp",
"dipteron",
"dipteronia",
"dipteryx",
"diptych",
"dipus",
"dipylon",
"dirac",
"dirca",
"direction",
"directionality",
"directive",
"directiveness",
"directivity",
"directness",
"director",
"directorate",
"directorship",
"directory",
"dirge",
"dirham",
"dirigible",
"dirk",
"dirndl",
"dirt",
"dirtiness",
"dirtying",
"disa",
"disability",
"disabled",
"disablement",
"disaccharidase",
"disaccharide",
"disadvantage",
"disaffection",
"disaffirmation",
"disagreement",
"disambiguation",
"disambiguator",
"disappearance",
"disappearing",
"disappointment",
"disapprobation",
"disapproval",
"disarmament",
"disarmer",
"disarming",
"disarrangement",
"disarray",
"disassembly",
"disassociation",
"disaster",
"disavowal",
"disbandment",
"disbarment",
"disbelief",
"disbursal",
"disbursement",
"disburser",
"disc",
"discant",
"discard",
"disceptation",
"discernability",
"discernment",
"discharge",
"discina",
"disciple",
"discipleship",
"disciplinarian",
"discipline",
"disclaimer",
"disclosure",
"disco",
"discocephali",
"discoglossidae",
"discography",
"discoloration",
"discolouration",
"discomfited",
"discomfiture",
"discomfort",
"discomposure",
"discomycete",
"discomycetes",
"disconcertion",
"disconcertment",
"disconnect",
"disconnection",
"discontent",
"discontentment",
"discontinuance",
"discontinuation",
"discontinuity",
"discord",
"discordance",
"discotheque",
"discount",
"discounter",
"discouragement",
"discourse",
"discourtesy",
"discoverer",
"discovery",
"discredit",
"discreetness",
"discrepancy",
"discreteness",
"discretion",
"discrimination",
"discriminator",
"discursiveness",
"discus",
"discussant",
"discussion",
"disdain",
"disdainfulness",
"disease",
"disembarkation",
"disembarkment",
"disembowelment",
"disenchantment",
"disengagement",
"disentanglement",
"disentangler",
"disequilibrium",
"disesteem",
"disfavor",
"disfavour",
"disfiguration",
"disfigurement",
"disfluency",
"disforestation",
"disfunction",
"disgorgement",
"disgrace",
"disgracefulness",
"disgruntlement",
"disguise",
"disgust",
"disgustingness",
"dish",
"dishabille",
"disharmony",
"dishcloth",
"disheartenment",
"dishful",
"dishonesty",
"dishonor",
"dishonour",
"dishpan",
"dishrag",
"dishtowel",
"dishware",
"dishwasher",
"dishwashing",
"dishwater",
"disillusion",
"disillusionment",
"disincentive",
"disinclination",
"disinfectant",
"disinfection",
"disinfestation",
"disinflation",
"disinformation",
"disinheritance",
"disintegration",
"disinterest",
"disinterment",
"disinvestment",
"disjointedness",
"disjunction",
"disjuncture",
"disk",
"diskette",
"dislike",
"dislocation",
"dislodgement",
"dislodgment",
"disloyalty",
"dismantlement",
"dismantling",
"dismay",
"dismemberment",
"dismissal",
"dismission",
"dismount",
"disney",
"disneyland",
"disobedience",
"disorder",
"disorderliness",
"disorganisation",
"disorganization",
"disorientation",
"disowning",
"disownment",
"disparagement",
"disparager",
"disparateness",
"disparity",
"dispassion",
"dispatch",
"dispatcher",
"dispensability",
"dispensableness",
"dispensary",
"dispensation",
"dispenser",
"dispersal",
"dispersion",
"dispiritedness",
"displacement",
"display",
"displeasure",
"disposable",
"disposal",
"disposition",
"dispossession",
"dispraise",
"disproof",
"disproportion",
"disprover",
"disputant",
"disputation",
"dispute",
"disquiet",
"disquietude",
"disquisition",
"disraeli",
"disregard",
"disrepair",
"disreputability",
"disrepute",
"disrespect",
"disruption",
"dissatisfaction",
"dissection",
"dissembler",
"dissembling",
"dissemination",
"disseminator",
"dissension",
"dissent",
"dissenter",
"dissertation",
"disservice",
"dissidence",
"dissident",
"dissilience",
"dissimilarity",
"dissimilation",
"dissimilitude",
"dissimulation",
"dissimulator",
"dissipation",
"dissociation",
"dissolubility",
"dissoluteness",
"dissolution",
"dissolve",
"dissolvent",
"dissolver",
"dissolving",
"dissonance",
"dissuasion",
"dissyllable",
"dissymmetry",
"distaff",
"distance",
"distaste",
"distastefulness",
"distemper",
"distension",
"distention",
"distich",
"distillate",
"distillation",
"distiller",
"distillery",
"distillment",
"distinction",
"distinctiveness",
"distinctness",
"distomatosis",
"distortion",
"distortionist",
"distraction",
"distraint",
"distress",
"distressfulness",
"distressingness",
"distributary",
"distributer",
"distribution",
"distributor",
"district",
"distrust",
"distrustfulness",
"disturbance",
"disturber",
"disulfiram",
"disunion",
"disunity",
"disuse",
"disyllable",
"dita",
"ditch",
"ditchmoss",
"dither",
"dithering",
"dithyramb",
"dittany",
"ditto",
"ditty",
"diuresis",
"diuretic",
"diuril",
"diva",
"divagation",
"divan",
"divarication",
"dive",
"diver",
"divergence",
"divergency",
"diverseness",
"diversification",
"diversion",
"diversionist",
"diversity",
"diverticulitis",
"diverticulosis",
"diverticulum",
"divertimento",
"divestiture",
"divide",
"dividend",
"divider",
"divination",
"divine",
"diviner",
"diving",
"divinity",
"divisibility",
"division",
"divisor",
"divorce",
"divorcee",
"divorcement",
"divot",
"divulgement",
"divulgence",
"divvy",
"diwan",
"dixie",
"dixiecrats",
"dixieland",
"dizziness",
"djakarta",
"djanet",
"djibouti",
"djiboutian",
"djinn",
"djinni",
"djinny",
"dmus",
"dnieper",
"dnipropetrovsk",
"dobbin",
"doberman",
"dobra",
"dobrich",
"dobson",
"dobsonfly",
"docent",
"docetism",
"docility",
"dock",
"dockage",
"docker",
"docket",
"dockhand",
"docking",
"dockside",
"dockworker",
"dockyard",
"doctor",
"doctorate",
"doctorfish",
"doctorow",
"doctorspeak",
"doctrinaire",
"doctrine",
"docudrama",
"document",
"documentary",
"documentation",
"dodder",
"dodderer",
"doddle",
"dodecagon",
"dodecahedron",
"dodecanese",
"dodge",
"dodgem",
"dodger",
"dodging",
"dodgson",
"dodo",
"dodoma",
"dodonaea",
"doei",
"doer",
"doeskin",
"dogbane",
"dogcart",
"doge",
"dogfight",
"dogfighter",
"dogfish",
"doggedness",
"doggerel",
"doggie",
"doggy",
"doghouse",
"dogie",
"dogleg",
"dogma",
"dogmatism",
"dogmatist",
"dogsbody",
"dogshit",
"dogsled",
"dogtooth",
"dogtrot",
"dogwatch",
"dogwood",
"dogy",
"doha",
"doily",
"doings",
"dojc",
"dolby",
"doldrums",
"dole",
"dolefulness",
"dolichocephalic",
"dolichocephaly",
"dolichonyx",
"dolichos",
"dolichotis",
"doliolidae",
"doliolum",
"doll",
"dollar",
"dollarfish",
"dollhouse",
"dollop",
"dolly",
"dolman",
"dolmas",
"dolmen",
"dolobid",
"dolomite",
"dolor",
"dolour",
"dolphin",
"dolphinfish",
"dolt",
"domain",
"domatium",
"dombeya",
"dome",
"domestic",
"domestication",
"domesticity",
"domicile",
"domiciliation",
"dominance",
"dominant",
"domination",
"dominatrix",
"domine",
"dominee",
"domineeringness",
"domingo",
"dominic",
"dominica",
"dominican",
"dominick",
"dominicus",
"dominie",
"dominion",
"dominique",
"domino",
"dominoes",
"dominos",
"dominus",
"domitian",
"dona",
"donar",
"donatello",
"donation",
"donatism",
"donatist",
"donatus",
"donbas",
"donbass",
"donee",
"donetsk",
"donetske",
"dong",
"dongle",
"donizetti",
"donjon",
"donkey",
"donkeywork",
"donkin",
"donna",
"donne",
"donor",
"donut",
"doob",
"doodad",
"doodia",
"doodle",
"doodlebug",
"doofus",
"doohickey",
"doojigger",
"doolittle",
"doom",
"doomed",
"doomsday",
"door",
"doorbell",
"doorcase",
"doorframe",
"doorhandle",
"doorjamb",
"doorkeeper",
"doorknob",
"doorknocker",
"doorlock",
"doorman",
"doormat",
"doornail",
"doorplate",
"doorpost",
"doorsill",
"doorstep",
"doorstop",
"doorstopper",
"doorway",
"dooryard",
"dopa",
"dopamine",
"dopastat",
"dope",
"doppelganger",
"doppelzentner",
"doppler",
"dorado",
"dorbeetle",
"dorian",
"doric",
"doriden",
"doris",
"dork",
"dorking",
"dorm",
"dormancy",
"dormer",
"dormition",
"dormitory",
"dormouse",
"doronicum",
"dorotheanthus",
"dorsiflexion",
"dorsum",
"dortmund",
"dory",
"dorylinae",
"doryopteris",
"dosage",
"dose",
"dosemeter",
"dosimeter",
"dosimetry",
"dossal",
"dossel",
"dosser",
"dosshouse",
"dossier",
"dostoevski",
"dostoevsky",
"dostoyevsky",
"dotage",
"dotard",
"dotrel",
"dotterel",
"dottle",
"douala",
"double",
"doubleheader",
"doubler",
"doubles",
"doublespeak",
"doublet",
"doublethink",
"doubleton",
"doubletree",
"doubling",
"doubloon",
"doubt",
"doubter",
"doubtfulness",
"douche",
"dough",
"doughboy",
"doughnut",
"douglas",
"douglass",
"doula",
"doura",
"dourah",
"douroucouli",
"dousing",
"dove",
"dovecote",
"dovekie",
"dover",
"dovetail",
"dovishness",
"dovyalis",
"dowager",
"dowdiness",
"dowding",
"dowdy",
"dowel",
"doweling",
"dower",
"dowery",
"dowitcher",
"dowland",
"down",
"downbeat",
"downcast",
"downdraft",
"downer",
"downfall",
"downgrade",
"downheartedness",
"downhill",
"downiness",
"downing",
"downpour",
"downrightness",
"downshift",
"downside",
"downsizing",
"downslope",
"downspin",
"downstage",
"downstroke",
"downswing",
"downtick",
"downtime",
"downtown",
"downturn",
"dowry",
"dowse",
"dowser",
"dowsing",
"doxazosin",
"doxepin",
"doxology",
"doxorubicin",
"doxy",
"doxycycline",
"doyen",
"doyenne",
"doyley",
"doyly",
"doze",
"dozen",
"dozens",
"dozer",
"dphil",
"dprk",
"drab",
"draba",
"drabness",
"dracaena",
"dracaenaceae",
"dracenaceae",
"drachm",
"drachma",
"draco",
"dracocephalum",
"dracontium",
"dracula",
"dracunculiasis",
"dracunculidae",
"dracunculus",
"draft",
"draftee",
"drafter",
"drafting",
"draftsman",
"draftsmanship",
"draftsperson",
"drag",
"dragee",
"dragger",
"dragnet",
"dragoman",
"dragon",
"dragonet",
"dragonfly",
"dragonhead",
"dragoon",
"dragunov",
"drain",
"drainage",
"drainboard",
"drainpipe",
"drainplug",
"drake",
"dram",
"drama",
"dramamine",
"dramatics",
"dramatisation",
"dramatist",
"dramatization",
"dramaturgy",
"drambuie",
"drape",
"draper",
"drapery",
"draught",
"draughts",
"draughtsman",
"dravidian",
"dravidic",
"draw",
"drawback",
"drawbar",
"drawbridge",
"drawee",
"drawer",
"drawers",
"drawing",
"drawknife",
"drawl",
"drawler",
"drawnwork",
"drawshave",
"drawstring",
"dray",
"drayhorse",
"dread",
"dreadfulness",
"dreadlock",
"dreadnaught",
"dreadnought",
"dream",
"dreamer",
"dreaminess",
"dreaming",
"dreamland",
"dreamworld",
"dreariness",
"dreck",
"dredge",
"dredger",
"dreg",
"dregs",
"dreiser",
"dreissena",
"drenching",
"drepanididae",
"drepanis",
"dresden",
"dress",
"dressage",
"dresser",
"dressing",
"dressmaker",
"dressmaking",
"drew",
"drey",
"dreyfus",
"drib",
"dribble",
"dribbler",
"dribbling",
"driblet",
"drier",
"drift",
"driftage",
"drifter",
"driftfish",
"drifting",
"driftwood",
"drill",
"drilling",
"drimys",
"drink",
"drinkable",
"drinker",
"drinking",
"drip",
"drippage",
"drippiness",
"dripping",
"drippings",
"dripstone",
"drive",
"drivel",
"driveller",
"driver",
"driveshaft",
"driveway",
"driving",
"drixoral",
"drizzle",
"drms",
"drogheda",
"drogue",
"drollery",
"dromaeosaur",
"dromaeosauridae",
"dromaius",
"drome",
"dromedary",
"dronabinol",
"drone",
"droning",
"drool",
"drooler",
"droop",
"drop",
"dropkick",
"dropkicker",
"droplet",
"dropline",
"dropout",
"dropper",
"droppings",
"dropseed",
"dropsy",
"drosera",
"droseraceae",
"droshky",
"drosky",
"drosophila",
"drosophilidae",
"drosophyllum",
"dross",
"drought",
"drouth",
"drove",
"drover",
"drowse",
"drowsiness",
"drubbing",
"drudge",
"drudgery",
"drug",
"drugget",
"drugging",
"druggist",
"drugstore",
"druid",
"druidism",
"drum",
"drumbeat",
"drumbeater",
"drumfire",
"drumfish",
"drumhead",
"drumlin",
"drummer",
"drumming",
"drumstick",
"drunk",
"drunkard",
"drunkenness",
"drupe",
"drupelet",
"druse",
"drusen",
"druthers",
"druze",
"dryad",
"dryadella",
"dryas",
"dryden",
"drydock",
"dryer",
"drygoods",
"drymarchon",
"drymoglossum",
"drynaria",
"dryness",
"dryopithecine",
"dryopithecus",
"dryopteridaceae",
"dryopteris",
"drypis",
"drywall",
"dscdna",
"dtic",
"duad",
"dualism",
"dualist",
"duality",
"dubai",
"dubbin",
"dubbing",
"dubiety",
"dubiousness",
"dublin",
"dubliner",
"dubnium",
"dubonnet",
"dubrovnik",
"dubuque",
"dubya",
"dubyuh",
"ducat",
"duce",
"duchamp",
"duchess",
"duchy",
"duck",
"duckbill",
"duckboard",
"ducking",
"duckling",
"duckpin",
"duckpins",
"duckweed",
"ducky",
"duct",
"ductileness",
"ductility",
"ductule",
"ductulus",
"dude",
"dudeen",
"dudgeon",
"duds",
"duel",
"dueler",
"duelist",
"dueller",
"duellist",
"duenna",
"duet",
"duette",
"duff",
"duffel",
"duffer",
"duffle",
"dufy",
"dugong",
"dugongidae",
"dugout",
"dukas",
"duke",
"dukedom",
"dulciana",
"dulcimer",
"dulcinea",
"dullard",
"dulles",
"dullness",
"dulse",
"duluth",
"duma",
"dumas",
"dumbass",
"dumbbell",
"dumbness",
"dumbwaiter",
"dumdum",
"dumetella",
"dummy",
"dump",
"dumpcart",
"dumper",
"dumpiness",
"dumping",
"dumpling",
"dumplings",
"dumps",
"dumpsite",
"dumpster",
"dumuzi",
"duncan",
"dunce",
"dunderhead",
"dune",
"dung",
"dungaree",
"dungeon",
"dunghill",
"dunk",
"dunkard",
"dunker",
"dunkerque",
"dunkers",
"dunkirk",
"dunlin",
"dunnock",
"duodecimal",
"duodenum",
"duologue",
"duomo",
"dupe",
"dupery",
"duplex",
"duplicability",
"duplicate",
"duplication",
"duplicator",
"duplicidentata",
"duplicity",
"dura",
"durability",
"durables",
"durabolin",
"duralumin",
"duramen",
"durance",
"durango",
"durant",
"durante",
"duration",
"durative",
"durazzo",
"durban",
"durbar",
"durer",
"duress",
"durga",
"durham",
"durian",
"durio",
"durion",
"durkheim",
"durmast",
"durra",
"durrell",
"durres",
"durum",
"dusanbe",
"duse",
"dushanbe",
"dusicyon",
"dusk",
"duskiness",
"dusseldorf",
"dust",
"dustbin",
"dustcart",
"dustcloth",
"duster",
"dustiness",
"dustman",
"dustmop",
"dustpan",
"dustpanful",
"dustrag",
"dustup",
"dutch",
"dutchman",
"dutifulness",
"duty",
"duvalier",
"duvet",
"dvorak",
"dwarf",
"dwarfishness",
"dwarfism",
"dweeb",
"dweller",
"dwelling",
"dwindling",
"dyad",
"dyarchy",
"dyaus",
"dybbuk",
"dyeing",
"dyer",
"dyestuff",
"dyeweed",
"dyewood",
"dying",
"dyirbal",
"dyke",
"dylan",
"dynamic",
"dynamics",
"dynamism",
"dynamite",
"dynamiter",
"dynamitist",
"dynamo",
"dynamometer",
"dynapen",
"dynast",
"dynasty",
"dyne",
"dysaphia",
"dysarthria",
"dyscalculia",
"dyschezia",
"dyscrasia",
"dysdercus",
"dysentery",
"dysfunction",
"dysgenesis",
"dysgenics",
"dysgraphia",
"dyskinesia",
"dyslectic",
"dyslexia",
"dyslexic",
"dyslogia",
"dysmenorrhea",
"dysomia",
"dysosmia",
"dyspepsia",
"dyspeptic",
"dysphagia",
"dysphasia",
"dysphemism",
"dysphonia",
"dysphoria",
"dysplasia",
"dyspnea",
"dyspnoea",
"dysprosium",
"dyssynergia",
"dysthymia",
"dystopia",
"dystrophy",
"dysuria",
"dytiscidae",
"dyushambe",
"dziggetai",
"eacles",
"eadwig",
"eager",
"eagerness",
"eagle",
"eaglet",
"eagre",
"eames",
"earache",
"eardrop",
"eardrum",
"earflap",
"earful",
"earhart",
"earl",
"earlap",
"earldom",
"earliness",
"earlobe",
"earmark",
"earmuff",
"earner",
"earnest",
"earnestness",
"earnings",
"earphone",
"earpiece",
"earplug",
"earreach",
"earring",
"earshot",
"earth",
"earthball",
"earthenware",
"earthing",
"earthling",
"earthman",
"earthnut",
"earthquake",
"earthstar",
"earthtongue",
"earthwork",
"earthworm",
"earwax",
"earwig",
"ease",
"easel",
"easement",
"easiness",
"easing",
"east",
"easter",
"easterly",
"easterner",
"eastertide",
"eastman",
"eastward",
"easygoingness",
"eatable",
"eatage",
"eater",
"eatery",
"eating",
"eats",
"eaves",
"eavesdropper",
"ebbing",
"ebbtide",
"ebenaceae",
"ebenales",
"ebionite",
"ebit",
"ebitda",
"eblis",
"ebola",
"ebonics",
"ebonite",
"ebony",
"ebro",
"ebullience",
"ebullition",
"eburnation",
"eburophyton",
"ecarte",
"ecballium",
"eccentric",
"eccentricity",
"ecchymosis",
"eccles",
"ecclesiastes",
"ecclesiastic",
"ecclesiasticism",
"ecclesiasticus",
"ecclesiology",
"eccm",
"eccyesis",
"ecdysiast",
"ecdysis",
"ecesis",
"echelon",
"echeneididae",
"echeneis",
"echidna",
"echidnophaga",
"echinacea",
"echinocactus",
"echinocereus",
"echinochloa",
"echinococcosis",
"echinococcus",
"echinoderm",
"echinodermata",
"echinoidea",
"echinops",
"echinus",
"echium",
"echo",
"echocardiogram",
"echocardiograph",
"echogram",
"echography",
"echolalia",
"echolocation",
"echovirus",
"eckhart",
"eclair",
"eclampsia",
"eclat",
"eclectic",
"eclecticism",
"eclecticist",
"eclipse",
"eclipsis",
"ecliptic",
"eclogue",
"ecobabble",
"ecologist",
"ecology",
"econometrician",
"econometrics",
"econometrist",
"economics",
"economiser",
"economist",
"economizer",
"economy",
"ecosoc",
"ecosystem",
"ecoterrorism",
"ecotourism",
"ecphonesis",
"ecrevisse",
"ecru",
"ecstasy",
"ectasia",
"ectasis",
"ectoblast",
"ectoderm",
"ectomorph",
"ectomorphy",
"ectoparasite",
"ectopia",
"ectopistes",
"ectoplasm",
"ectoproct",
"ectoprocta",
"ectotherm",
"ectozoan",
"ectozoon",
"ectrodactyly",
"ecuador",
"ecuadoran",
"ecuadorian",
"ecumenicalism",
"ecumenicism",
"ecumenism",
"eczema",
"edacity",
"edam",
"edaphosauridae",
"edaphosaurus",
"edda",
"eddington",
"eddo",
"eddy",
"edecrin",
"edelweiss",
"edema",
"eden",
"edentata",
"edentate",
"ederle",
"edgar",
"edge",
"edger",
"edginess",
"edging",
"edibility",
"edible",
"edibleness",
"edict",
"edification",
"edifice",
"edinburgh",
"edirne",
"edison",
"editing",
"edition",
"editor",
"editorial",
"editorialist",
"editorship",
"edmonton",
"edmontonia",
"edmontosaurus",
"edronax",
"edta",
"educatee",
"education",
"educationalist",
"educationist",
"educator",
"edutainment",
"edward",
"edwardian",
"edwards",
"edwin",
"edwy",
"eelam",
"eelblenny",
"eelgrass",
"eelpout",
"eelworm",
"eeriness",
"effacement",
"effect",
"effecter",
"effectiveness",
"effectivity",
"effector",
"effects",
"effectuality",
"effectualness",
"effectuation",
"effeminacy",
"effeminateness",
"effendi",
"efferent",
"effervescence",
"efficaciousness",
"efficacy",
"efficiency",
"effigy",
"effleurage",
"efflorescence",
"effluence",
"effluent",
"effluvium",
"efflux",
"effort",
"effortfulness",
"effortlessness",
"effrontery",
"effulgence",
"effusion",
"effusiveness",
"egalitarian",
"egalitarianism",
"egalite",
"egality",
"egbert",
"egeria",
"eggar",
"eggbeater",
"eggcup",
"egger",
"eggfruit",
"egghead",
"eggnog",
"eggplant",
"eggs",
"eggshake",
"eggshell",
"eggwhisk",
"egis",
"eglantine",
"eglevsky",
"egocentric",
"egocentrism",
"egoism",
"egoist",
"egomania",
"egomaniac",
"egotism",
"egotist",
"egress",
"egression",
"egret",
"egretta",
"egtk",
"egypt",
"egyptian",
"egyptologist",
"egyptology",
"ehadhamen",
"ehrenberg",
"ehrlich",
"eibit",
"eichhornia",
"eichmann",
"eider",
"eiderdown",
"eidos",
"eiffel",
"eigen",
"eigenvalue",
"eight",
"eighteen",
"eighteenth",
"eighter",
"eighth",
"eighties",
"eightieth",
"eightpence",
"eightsome",
"eightvo",
"eighty",
"eijkman",
"eimeria",
"eimeriidae",
"eindhoven",
"einstein",
"einsteinium",
"einthoven",
"eira",
"eire",
"eisegesis",
"eisenhower",
"eisenstaedt",
"eisenstein",
"eisteddfod",
"ejaculate",
"ejaculation",
"ejaculator",
"ejection",
"ejector",
"ekman",
"elaborateness",
"elaboration",
"elaeagnaceae",
"elaeagnus",
"elaeis",
"elaeocarpaceae",
"elaeocarpus",
"elagatis",
"elam",
"elamite",
"elamitic",
"elan",
"eland",
"elanoides",
"elanus",
"elaphe",
"elaphure",
"elaphurus",
"elapid",
"elapidae",
"elasmobranch",
"elasmobranchii",
"elastance",
"elastase",
"elastic",
"elasticity",
"elastin",
"elastomer",
"elastoplast",
"elastosis",
"elater",
"elaterid",
"elateridae",
"elation",
"elavil",
"elbe",
"elbow",
"elbowing",
"elder",
"elderberry",
"elderly",
"eldership",
"eldest",
"eldorado",
"elecampane",
"elect",
"election",
"electioneering",
"elective",
"elector",
"electorate",
"electra",
"electric",
"electrician",
"electricity",
"electrification",
"electrocautery",
"electrocution",
"electrocutioner",
"electrode",
"electrograph",
"electrologist",
"electrolysis",
"electrolyte",
"electrolytic",
"electromagnet",
"electrometer",
"electromyogram",
"electromyograph",
"electron",
"electronics",
"electrophoresis",
"electrophoridae",
"electrophorus",
"electroplate",
"electroplater",
"electroscope",
"electroshock",
"electrosleep",
"electrostatics",
"electrosurgery",
"electrotherapy",
"electrum",
"elegance",
"elegist",
"elegy",
"element",
"elements",
"elemi",
"eleocharis",
"eleotridae",
"elephant",
"elephantiasis",
"elephantidae",
"elephantopus",
"elephas",
"elettaria",
"eleusine",
"elevated",
"elevation",
"elevator",
"eleven",
"eleventh",
"elgar",
"elia",
"elicitation",
"eligibility",
"elijah",
"elimination",
"eliminator",
"elint",
"elinvar",
"eliomys",
"eliot",
"elisa",
"elisabethville",
"elision",
"elite",
"elitism",
"elitist",
"elixir",
"elixophyllin",
"elizabeth",
"elizabethan",
"elkhound",
"elkwood",
"ellas",
"elli",
"ellington",
"ellipse",
"ellipsis",
"ellipsoid",
"ellipticity",
"ellison",
"ellsworth",
"ellul",
"elmont",
"elmwood",
"elocution",
"elocutionist",
"elodea",
"elongation",
"elopement",
"elopidae",
"elops",
"eloquence",
"elsass",
"elsholtzia",
"elspar",
"eluate",
"elucidation",
"eluding",
"elul",
"elusion",
"elusiveness",
"elution",
"elver",
"elves",
"elvis",
"elymus",
"elysium",
"elytron",
"emaciation",
"email",
"emanation",
"emancipation",
"emancipationist",
"emancipator",
"emasculation",
"embalmer",
"embalmment",
"embankment",
"embargo",
"embarkation",
"embarkment",
"embarrassment",
"embassador",
"embassy",
"embayment",
"embellishment",
"ember",
"emberiza",
"emberizidae",
"embezzlement",
"embezzler",
"embiodea",
"embioptera",
"embiotocidae",
"embitterment",
"emblem",
"embodiment",
"embolectomy",
"embolism",
"embolus",
"embonpoint",
"embossment",
"embothrium",
"embouchure",
"embrace",
"embracement",
"embracing",
"embrasure",
"embrocation",
"embroiderer",
"embroideress",
"embroidery",
"embroilment",
"embryo",
"embryologist",
"embryology",
"emcee",
"emda",
"emeer",
"emendation",
"emerald",
"emergence",
"emergency",
"emeritus",
"emersion",
"emerson",
"emery",
"emeside",
"emesis",
"emetic",
"emetrol",
"emigrant",
"emigration",
"emigre",
"emigree",
"emile",
"emilia",
"eminence",
"emir",
"emirate",
"emissary",
"emission",
"emitter",
"emmanthe",
"emmenagogue",
"emmental",
"emmentaler",
"emmenthal",
"emmenthaler",
"emmer",
"emmet",
"emmetropia",
"emmy",
"emollient",
"emolument",
"emoticon",
"emotion",
"emotionalism",
"emotionality",
"emotionlessness",
"empathy",
"empedocles",
"empennage",
"emperor",
"empetraceae",
"empetrum",
"emphasis",
"emphasizing",
"emphysema",
"empire",
"empiricism",
"empiricist",
"empirin",
"emplacement",
"employ",
"employable",
"employee",
"employer",
"employment",
"emporium",
"empowerment",
"empress",
"emptiness",
"emptor",
"empty",
"emptying",
"empyema",
"empyrean",
"emulation",
"emulator",
"emulsifier",
"emulsion",
"emydidae",
"enactment",
"enalapril",
"enallage",
"enamel",
"enamelware",
"enamine",
"enamoredness",
"enanthem",
"enanthema",
"enantiomer",
"enantiomorph",
"enantiomorphism",
"enarthrosis",
"enate",
"enation",
"enbrel",
"encainide",
"encampment",
"encapsulation",
"encasement",
"encaustic",
"encelia",
"enceliopsis",
"encephalartos",
"encephalitis",
"encephalocele",
"encephalogram",
"encephalography",
"encephalon",
"encephalopathy",
"enchanter",
"enchantment",
"enchantress",
"enchilada",
"enchiridion",
"enchondroma",
"encirclement",
"enclave",
"enclosing",
"enclosure",
"encoding",
"encolure",
"encomium",
"encompassment",
"encopresis",
"encore",
"encounter",
"encouragement",
"encroacher",
"encroachment",
"encrustation",
"encryption",
"enculturation",
"encumbrance",
"encyclia",
"encyclical",
"encyclopaedia",
"encyclopaedism",
"encyclopaedist",
"encyclopedia",
"encyclopedism",
"encyclopedist",
"endaemonism",
"endameba",
"endamoeba",
"endamoebidae",
"endangerment",
"endarterectomy",
"endarteritis",
"endearment",
"endeavor",
"endeavour",
"endecott",
"endemic",
"endemism",
"endgame",
"endicott",
"ending",
"endive",
"endlessness",
"endoblast",
"endocarditis",
"endocardium",
"endocarp",
"endocervicitis",
"endocranium",
"endocrine",
"endocrinologist",
"endocrinology",
"endoderm",
"endodontia",
"endodontics",
"endodontist",
"endogamy",
"endogen",
"endogeny",
"endolymph",
"endometriosis",
"endometritis",
"endometrium",
"endomorph",
"endomorphy",
"endomycetales",
"endoneurium",
"endonuclease",
"endoparasite",
"endoplasm",
"endoprocta",
"endorphin",
"endorsement",
"endorser",
"endoscope",
"endoscopy",
"endoskeleton",
"endosperm",
"endospore",
"endosteum",
"endothelium",
"endotoxin",
"endowment",
"endozoan",
"endplate",
"endpoint",
"endurance",
"enduringness",
"enema",
"enemy",
"energid",
"energiser",
"energizer",
"energizing",
"energy",
"enervation",
"enesco",
"enets",
"enfeeblement",
"enfeoffment",
"enfilade",
"enflurane",
"enfolding",
"enforcement",
"enforcer",
"enfranchisement",
"engagement",
"engelmannia",
"engels",
"engine",
"engineer",
"engineering",
"enginery",
"england",
"english",
"englishman",
"englishwoman",
"engorgement",
"engram",
"engraulidae",
"engraulis",
"engraver",
"engraving",
"engrossment",
"enhancement",
"enhancer",
"enhydra",
"enid",
"enigma",
"eniwetok",
"enjambement",
"enjambment",
"enjoining",
"enjoinment",
"enjoyableness",
"enjoyer",
"enjoyment",
"enkaid",
"enkephalin",
"enki",
"enkidu",
"enlargement",
"enlarger",
"enlightened",
"enlightenment",
"enlil",
"enlistee",
"enlisting",
"enlistment",
"enlivener",
"enmity",
"ennead",
"ennoblement",
"ennui",
"enol",
"enologist",
"enology",
"enophile",
"enormity",
"enormousness",
"enosis",
"enough",
"enovid",
"enquirer",
"enquiry",
"enragement",
"enrichment",
"enrollee",
"enrollment",
"enrolment",
"ensemble",
"ensete",
"ensign",
"ensilage",
"ensis",
"enslavement",
"entablature",
"entail",
"entailment",
"entandrophragma",
"entanglement",
"entasis",
"entebbe",
"entelea",
"entelechy",
"entellus",
"entente",
"enterics",
"entering",
"enteritis",
"enterobacteria",
"enterobiasis",
"enterobius",
"enteroceptor",
"enterokinase",
"enterolith",
"enterolithiasis",
"enterolobium",
"enteron",
"enteropathy",
"enteroptosis",
"enterostenosis",
"enterostomy",
"enterotomy",
"enterotoxemia",
"enterotoxin",
"enterovirus",
"enterprise",
"enterpriser",
"entertainer",
"entertainment",
"enthalpy",
"enthrallment",
"enthronement",
"enthronisation",
"enthronization",
"enthusiasm",
"enthusiast",
"enticement",
"entire",
"entireness",
"entirety",
"entitlement",
"entity",
"entlebucher",
"entoblast",
"entoderm",
"entoloma",
"entolomataceae",
"entombment",
"entomion",
"entomologist",
"entomology",
"entomophobia",
"entomophthora",
"entomostraca",
"entoparasite",
"entoproct",
"entoprocta",
"entourage",
"entozoan",
"entozoon",
"entrails",
"entrance",
"entrancement",
"entranceway",
"entrant",
"entrapment",
"entreaty",
"entrecote",
"entree",
"entremets",
"entrenchment",
"entrepot",
"entrepreneur",
"entresol",
"entric",
"entropy",
"entry",
"entryway",
"entsi",
"entsy",
"enucleation",
"enuki",
"enumeration",
"enumerator",
"enunciation",
"enuresis",
"envelope",
"envelopment",
"enviousness",
"environment",
"environs",
"envisioning",
"envoi",
"envoy",
"envy",
"enzyme",
"enzymologist",
"enzymology",
"eocene",
"eohippus",
"eolian",
"eolic",
"eolith",
"eolithic",
"eoraptor",
"eosin",
"eosinopenia",
"eosinophil",
"eosinophile",
"eosinophilia",
"epacridaceae",
"epacris",
"epanalepsis",
"epanaphora",
"epanodos",
"epanorthosis",
"eparch",
"eparchy",
"epaulet",
"epaulette",
"epauliere",
"epee",
"ependyma",
"epenthesis",
"epergne",
"epha",
"ephah",
"ephedra",
"ephedraceae",
"ephedrine",
"ephemera",
"ephemeral",
"ephemerality",
"ephemeralness",
"ephemerid",
"ephemerida",
"ephemeridae",
"ephemeris",
"ephemeron",
"ephemeroptera",
"ephemeropteran",
"ephesian",
"ephesians",
"ephestia",
"ephesus",
"ephippidae",
"epic",
"epicalyx",
"epicanthus",
"epicardia",
"epicardium",
"epicarp",
"epicene",
"epicenter",
"epicentre",
"epicondyle",
"epicondylitis",
"epicranium",
"epictetus",
"epicure",
"epicurean",
"epicureanism",
"epicurism",
"epicurus",
"epicycle",
"epicycloid",
"epidemic",
"epidemiologist",
"epidemiology",
"epidendron",
"epidendrum",
"epidermis",
"epidiascope",
"epididymis",
"epididymitis",
"epidural",
"epigaea",
"epigastrium",
"epigenesis",
"epiglottis",
"epiglottitis",
"epigon",
"epigone",
"epigram",
"epigraph",
"epigraphy",
"epikeratophakia",
"epilachna",
"epilation",
"epilator",
"epilepsy",
"epileptic",
"epilobium",
"epilog",
"epilogue",
"epimedium",
"epimetheus",
"epinephelus",
"epinephrin",
"epinephrine",
"epipactis",
"epipaleolithic",
"epiphany",
"epiphenomenon",
"epiphora",
"epiphyllum",
"epiphysis",
"epiphyte",
"epiplexis",
"epipremnum",
"epirus",
"episcia",
"episcleritis",
"episcopacy",
"episcopalian",
"episcopalianism",
"episcopate",
"episiotomy",
"episode",
"episome",
"epispadias",
"episperm",
"epistasis",
"epistaxis",
"episteme",
"epistemologist",
"epistemology",
"epistle",
"epistrophe",
"epitaph",
"epitaxy",
"epithalamium",
"epithelioma",
"epithelium",
"epithet",
"epitome",
"epitope",
"epizoan",
"epizoon",
"epoch",
"epona",
"eponym",
"eponymy",
"epos",
"epoxy",
"eprom",
"epsilon",
"epstein",
"eptatretus",
"eptesicus",
"equal",
"equalisation",
"equaliser",
"equalitarian",
"equalitarianism",
"equality",
"equalization",
"equalizer",
"equanil",
"equanimity",
"equatability",
"equating",
"equation",
"equator",
"equatorial",
"equerry",
"equestrian",
"equetus",
"equid",
"equidae",
"equilateral",
"equilibration",
"equilibrium",
"equine",
"equinoctial",
"equinox",
"equipage",
"equipment",
"equipoise",
"equipping",
"equisetaceae",
"equisetales",
"equisetatae",
"equisetum",
"equitation",
"equity",
"equivalence",
"equivalent",
"equivocalness",
"equivocation",
"equivocator",
"equus",
"eradication",
"eradicator",
"eragrostis",
"eranthis",
"eraser",
"erasmus",
"erastianism",
"erasure",
"erato",
"eratosthenes",
"erbium",
"ercilla",
"erebus",
"erecting",
"erection",
"erectness",
"eremite",
"eremitism",
"ereshkigal",
"ereshkigel",
"erethism",
"erethizon",
"erethizontidae",
"eretmochelys",
"erewhon",
"ergocalciferol",
"ergodicity",
"ergometer",
"ergonomics",
"ergonovine",
"ergosterol",
"ergot",
"ergotamine",
"ergotism",
"ergotropism",
"erianthus",
"erica",
"ericaceae",
"ericales",
"eridanus",
"erie",
"erigeron",
"erignathus",
"erin",
"erinaceidae",
"erinaceus",
"eringo",
"erinyes",
"eriobotrya",
"eriocaulaceae",
"eriocaulon",
"eriodictyon",
"eriogonum",
"eriophorum",
"eriophyllum",
"eriosoma",
"eris",
"eristic",
"erithacus",
"eritrea",
"eritrean",
"erivan",
"erlang",
"erlenmeyer",
"ermine",
"erne",
"ernst",
"eroding",
"erodium",
"erolia",
"eros",
"erosion",
"erotic",
"erotica",
"eroticism",
"erotism",
"errancy",
"errand",
"erratum",
"erroneousness",
"error",
"ersatz",
"erse",
"eruca",
"eructation",
"eruditeness",
"erudition",
"eruption",
"erving",
"erwinia",
"eryngium",
"eryngo",
"erysimum",
"erysipelas",
"erysiphaceae",
"erysiphales",
"erysiphe",
"erythema",
"erythrina",
"erythrite",
"erythroblast",
"erythrocebus",
"erythrocin",
"erythrocyte",
"erythroderma",
"erythrolysin",
"erythromycin",
"erythronium",
"erythropoiesis",
"erythropoietin",
"erythroxylaceae",
"erythroxylon",
"erythroxylum",
"esaki",
"esau",
"escadrille",
"escalade",
"escalader",
"escalation",
"escalator",
"escallop",
"escapade",
"escape",
"escapee",
"escapement",
"escapism",
"escapist",
"escapologist",
"escapology",
"escargot",
"escarole",
"escarp",
"escarpment",
"eschalot",
"eschar",
"eschatologist",
"eschatology",
"eschaton",
"escheat",
"escherichia",
"eschrichtiidae",
"eschrichtius",
"eschscholtzia",
"escolar",
"escort",
"escritoire",
"escrow",
"escudo",
"escutcheon",
"esfahan",
"esidrix",
"eskalith",
"esker",
"eskimo",
"esmolol",
"esocidae",
"esop",
"esophagitis",
"esophagoscope",
"esophagus",
"esoterica",
"esotropia",
"esox",
"espadrille",
"espagnole",
"espalier",
"espana",
"esparcet",
"esperantido",
"esperanto",
"espial",
"espionage",
"esplanade",
"espoo",
"espousal",
"espresso",
"esprit",
"esquimau",
"esquire",
"essay",
"essayer",
"essayist",
"esselen",
"essen",
"essence",
"essene",
"essential",
"essentiality",
"essentialness",
"essex",
"essonite",
"establishment",
"estaminet",
"estate",
"estazolam",
"esteem",
"ester",
"esther",
"esthesia",
"esthesis",
"esthete",
"esthetic",
"esthetician",
"esthetics",
"esthonia",
"esthonian",
"estimate",
"estimation",
"estimator",
"estivation",
"estonia",
"estonian",
"estoppel",
"estradiol",
"estragon",
"estrangement",
"estrilda",
"estriol",
"estrogen",
"estrone",
"estronol",
"estrus",
"estuary",
"esurience",
"etagere",
"etamin",
"etamine",
"etanercept",
"etcetera",
"etcher",
"etching",
"eternity",
"ethanal",
"ethanamide",
"ethane",
"ethanediol",
"ethanoate",
"ethanol",
"ethchlorvynol",
"ethelbert",
"ethelred",
"ethene",
"ether",
"ethernet",
"ethic",
"ethician",
"ethicism",
"ethicist",
"ethics",
"ethiopia",
"ethiopian",
"ethmoid",
"ethnarch",
"ethnic",
"ethnicity",
"ethnocentrism",
"ethnographer",
"ethnography",
"ethnologist",
"ethnology",
"ethnos",
"ethocaine",
"ethologist",
"ethology",
"ethos",
"ethosuximide",
"ethoxyethane",
"ethrane",
"ethril",
"ethyl",
"ethylene",
"ethyne",
"etiolation",
"etiologist",
"etiology",
"etiquette",
"etna",
"etodolac",
"etonian",
"etropus",
"etruria",
"etruscan",
"etude",
"etui",
"etymologist",
"etymologizing",
"etymology",
"etymon",
"euarctos",
"euascomycetes",
"eubacteria",
"eubacteriales",
"eubacterium",
"eubryales",
"eucalypt",
"eucalyptus",
"eucarya",
"eucaryote",
"eucharist",
"euchre",
"eucinostomus",
"euclid",
"eudaemon",
"eudaemonia",
"eudaimonia",
"eudemon",
"eudemonism",
"euderma",
"eudiometer",
"eudyptes",
"eugene",
"eugenia",
"eugenics",
"euglena",
"euglenaceae",
"euglenid",
"euglenoid",
"euglenophyceae",
"euglenophyta",
"euglenophyte",
"eukaryote",
"euler",
"eulogist",
"eulogium",
"eulogy",
"eumeces",
"eumenes",
"eumenides",
"eumetopias",
"eumops",
"eumycetes",
"eumycota",
"eunectes",
"eunuch",
"eunuchoidism",
"euonymus",
"eupatorium",
"euphagus",
"euphausiacea",
"euphemism",
"euphonium",
"euphony",
"euphorbia",
"euphorbiaceae",
"euphorbium",
"euphoria",
"euphoriant",
"euphory",
"euphractus",
"euphrates",
"euphrosyne",
"euphuism",
"euplectella",
"eupnea",
"eupnoea",
"euproctis",
"eurafrican",
"eurasia",
"eurasian",
"eureka",
"eurhythmics",
"eurhythmy",
"euripides",
"euro",
"eurobabble",
"eurocentrism",
"eurocurrency",
"eurodollar",
"euronithopod",
"euronithopoda",
"europa",
"europan",
"europe",
"european",
"europeanisation",
"europeanization",
"europium",
"europol",
"eurotiales",
"eurotium",
"euryale",
"euryalida",
"eurydice",
"eurylaimi",
"eurylaimidae",
"eurypterid",
"eurypterida",
"eurythmics",
"eurythmy",
"eusebius",
"eusporangium",
"eustachio",
"eustoma",
"eutamias",
"eutectic",
"euterpe",
"euthanasia",
"euthenics",
"eutheria",
"eutherian",
"euthynnus",
"eutrophication",
"evacuation",
"evacuee",
"evaluation",
"evaluator",
"evanescence",
"evangel",
"evangelicalism",
"evangelism",
"evangelist",
"evans",
"evansville",
"evaporation",
"evaporite",
"evaporometer",
"evasion",
"evasiveness",
"even",
"evenfall",
"evening",
"eveningwear",
"evenk",
"evenki",
"evenness",
"evensong",
"event",
"eventide",
"eventration",
"eventuality",
"everest",
"everglades",
"evergreen",
"everlasting",
"everlastingness",
"evernia",
"evers",
"eversion",
"evert",
"everting",
"everydayness",
"everyman",
"eviction",
"evidence",
"evil",
"evildoer",
"evildoing",
"evilness",
"evisceration",
"evocation",
"evolution",
"evolutionism",
"evolutionist",
"ewenki",
"ewer",
"exabit",
"exabyte",
"exacerbation",
"exacta",
"exaction",
"exactitude",
"exactness",
"exacum",
"exaeretodon",
"exaggeration",
"exaltation",
"exam",
"examen",
"examination",
"examinee",
"examiner",
"example",
"exanthem",
"exanthema",
"exarch",
"exarchate",
"exasperation",
"exbibit",
"exbibyte",
"excalibur",
"excavation",
"excavator",
"exceedance",
"excellence",
"excellency",
"excelsior",
"exception",
"excerpt",
"excerption",
"excess",
"excessiveness",
"exchange",
"exchangeability",
"exchanger",
"exchequer",
"excise",
"exciseman",
"excision",
"excitability",
"excitableness",
"excitant",
"excitation",
"excitement",
"exclaiming",
"exclamation",
"exclusion",
"exclusive",
"exclusiveness",
"excogitation",
"excogitator",
"excommunication",
"excoriation",
"excrement",
"excrescence",
"excreta",
"excreting",
"excretion",
"excruciation",
"exculpation",
"excursion",
"excursionist",
"excursus",
"excuse",
"excuser",
"exec",
"execration",
"executability",
"executant",
"executing",
"execution",
"executioner",
"executive",
"executor",
"executrix",
"exegesis",
"exegete",
"exemplar",
"exemplification",
"exemption",
"exenteration",
"exercise",
"exerciser",
"exercising",
"exercycle",
"exertion",
"exfoliation",
"exhalation",
"exhaust",
"exhaustion",
"exhibit",
"exhibition",
"exhibitioner",
"exhibitionism",
"exhibitionist",
"exhibitor",
"exhilaration",
"exhortation",
"exhumation",
"exigency",
"exiguity",
"exile",
"existence",
"existentialism",
"existentialist",
"exit",
"exmoor",
"exobiology",
"exocarp",
"exocet",
"exocoetidae",
"exocrine",
"exocycloida",
"exode",
"exoderm",
"exodontia",
"exodontics",
"exodontist",
"exodus",
"exogamy",
"exogen",
"exomphalos",
"exon",
"exoneration",
"exonuclease",
"exophthalmos",
"exopterygota",
"exorbitance",
"exorciser",
"exorcism",
"exorcist",
"exordium",
"exoskeleton",
"exosphere",
"exostosis",
"exotherm",
"exoticism",
"exoticness",
"exotism",
"exotoxin",
"exotropia",
"expanse",
"expansion",
"expansionism",
"expansiveness",
"expansivity",
"expat",
"expatiation",
"expatriate",
"expatriation",
"expectancy",
"expectation",
"expectedness",
"expectorant",
"expectoration",
"expectorator",
"expedience",
"expediency",
"expedient",
"expedition",
"expeditiousness",
"expelling",
"expender",
"expending",
"expenditure",
"expense",
"expensiveness",
"experience",
"experiment",
"experimentalism",
"experimentation",
"experimenter",
"expert",
"expertise",
"expertness",
"expiation",
"expiration",
"expiry",
"explanandum",
"explanans",
"explanation",
"expletive",
"explicandum",
"explication",
"explicitness",
"exploit",
"exploitation",
"exploiter",
"exploration",
"explorer",
"explosion",
"explosive",
"expo",
"exponent",
"exponential",
"exponentiation",
"export",
"exportation",
"exporter",
"exporting",
"expose",
"exposition",
"expositor",
"expostulation",
"exposure",
"expounder",
"expounding",
"express",
"expressage",
"expression",
"expressionism",
"expressionist",
"expressiveness",
"expressway",
"expropriation",
"expulsion",
"expunction",
"expunging",
"expurgation",
"expurgator",
"exquisiteness",
"extemporisation",
"extemporization",
"extension",
"extensiveness",
"extensor",
"extent",
"extenuation",
"exterior",
"exteriorisation",
"exteriorization",
"extermination",
"exterminator",
"extern",
"external",
"externalisation",
"externality",
"externalization",
"exteroception",
"exteroceptor",
"extinction",
"extinguisher",
"extinguishing",
"extirpation",
"extoller",
"extolment",
"extortion",
"extortioner",
"extortionist",
"extra",
"extract",
"extraction",
"extractor",
"extradition",
"extrados",
"extraneousness",
"extrapolation",
"extrasystole",
"extravagance",
"extravagancy",
"extravaganza",
"extravasation",
"extraversion",
"extravert",
"extreme",
"extremeness",
"extremism",
"extremist",
"extremity",
"extremum",
"extrication",
"extropy",
"extroversion",
"extrovert",
"extrusion",
"exuberance",
"exudate",
"exudation",
"exultation",
"exurbia",
"exuviae",
"eyas",
"eyck",
"eyeball",
"eyebath",
"eyebrow",
"eyecup",
"eyedness",
"eyedrop",
"eyeful",
"eyeglass",
"eyeglasses",
"eyehole",
"eyeish",
"eyelash",
"eyelessness",
"eyelet",
"eyelid",
"eyeliner",
"eyepatch",
"eyepiece",
"eyes",
"eyeshade",
"eyeshadow",
"eyeshot",
"eyesight",
"eyesore",
"eyespot",
"eyestrain",
"eyetooth",
"eyewash",
"eyewitness",
"eyra",
"eyre",
"eyrie",
"eyrir",
"eyry",
"eysenck",
"ezechiel",
"ezed",
"ezekias",
"ezekiel",
"ezra",
"fabaceae",
"faberge",
"fabian",
"fabiana",
"fabianism",
"fable",
"fabric",
"fabrication",
"fabricator",
"fabulist",
"facade",
"face",
"facelift",
"faceplate",
"facer",
"facet",
"facetiousness",
"facia",
"facial",
"facilitation",
"facilitator",
"facility",
"facing",
"facsimile",
"fact",
"faction",
"factoid",
"factor",
"factorial",
"factoring",
"factorisation",
"factorization",
"factory",
"factotum",
"factuality",
"factualness",
"facula",
"faculty",
"faddist",
"fade",
"fadeout",
"fading",
"fado",
"faecalith",
"faeces",
"faerie",
"faeroes",
"faeroese",
"faery",
"fafnir",
"fagaceae",
"fagales",
"faggot",
"faggoting",
"fagin",
"fagopyrum",
"fagot",
"fagoting",
"fagus",
"fahd",
"fahrenheit",
"faience",
"failing",
"faille",
"failure",
"faineance",
"faint",
"faintness",
"fair",
"fairbanks",
"fairground",
"fairlead",
"fairness",
"fairway",
"fairy",
"fairyland",
"fairytale",
"faisal",
"faisalabad",
"faith",
"faithful",
"faithfulness",
"faithlessness",
"fake",
"fakeer",
"faker",
"fakery",
"fakir",
"falafel",
"falanga",
"falange",
"falangist",
"falcatifolium",
"falchion",
"falco",
"falcon",
"falconer",
"falconidae",
"falconiformes",
"falconry",
"falderol",
"falkner",
"fall",
"falla",
"fallaciousness",
"fallacy",
"fallal",
"fallback",
"fallboard",
"faller",
"fallibility",
"falloff",
"fallopio",
"fallopius",
"fallot",
"fallout",
"fallow",
"falls",
"falsehood",
"falseness",
"falsetto",
"falsie",
"falsification",
"falsifier",
"falsifying",
"falsity",
"falstaff",
"falter",
"faltering",
"fame",
"familiar",
"familiarisation",
"familiarity",
"familiarization",
"family",
"famine",
"famishment",
"famotidine",
"famulus",
"fanaloka",
"fanatic",
"fanaticism",
"fanatism",
"fancier",
"fancy",
"fancywork",
"fandango",
"fandom",
"fanfare",
"fang",
"fanion",
"fanjet",
"fanlight",
"fanny",
"fantail",
"fantan",
"fantasia",
"fantasist",
"fantasm",
"fantast",
"fantasy",
"fantods",
"fanweed",
"fanwort",
"faqir",
"faquir",
"farad",
"faraday",
"farandole",
"farawayness",
"farc",
"farce",
"fardel",
"fare",
"farewell",
"farfalle",
"fargo",
"farina",
"farkleberry",
"farm",
"farmer",
"farmerette",
"farmhand",
"farmhouse",
"farming",
"farmington",
"farmland",
"farmplace",
"farmstead",
"farmyard",
"farness",
"faro",
"faroes",
"faroese",
"farrago",
"farragut",
"farrell",
"farrier",
"farrow",
"farrowing",
"farsi",
"farsightedness",
"fart",
"farthing",
"farthingale",
"farting",
"fartlek",
"fasces",
"fascia",
"fascicle",
"fasciculation",
"fascicule",
"fasciculus",
"fascination",
"fasciola",
"fascioliasis",
"fasciolidae",
"fasciolopsiasis",
"fasciolopsis",
"fasciolosis",
"fascism",
"fascist",
"fascista",
"fashion",
"fashioning",
"fashionmonger",
"fast",
"fastball",
"fastener",
"fastening",
"fastidiousness",
"fasting",
"fastnacht",
"fastness",
"fatah",
"fatalism",
"fatalist",
"fatality",
"fatback",
"fate",
"fathead",
"father",
"fatherhood",
"fatherland",
"fatherliness",
"fathom",
"fathometer",
"fatigability",
"fatigue",
"fatigues",
"fatiha",
"fatihah",
"fatima",
"fatimah",
"fatism",
"fatness",
"fatso",
"fattiness",
"fattism",
"fatty",
"fatuity",
"fatuousness",
"fatwa",
"fatwah",
"faubourg",
"fauces",
"faucet",
"fauld",
"faulkner",
"fault",
"faultfinder",
"faultfinding",
"faultiness",
"faulting",
"faultlessness",
"faun",
"fauna",
"fauntleroy",
"faunus",
"faust",
"faustus",
"fauteuil",
"fauve",
"fauvism",
"fauvist",
"favism",
"favor",
"favorableness",
"favorite",
"favoritism",
"favour",
"favourableness",
"favourite",
"favouritism",
"favus",
"fawkes",
"fawn",
"fawner",
"fayetteville",
"fdic",
"fealty",
"fear",
"fearfulness",
"fearlessness",
"feasibility",
"feasibleness",
"feast",
"feasting",
"feat",
"feather",
"featherbed",
"featherbedding",
"featheredge",
"featherfoil",
"featheriness",
"feathering",
"feathertop",
"featherweight",
"feature",
"febricity",
"febrifuge",
"febrility",
"february",
"fecalith",
"feces",
"fechner",
"fecklessness",
"fecula",
"feculence",
"fecundation",
"fecundity",
"fedayeen",
"fedelline",
"federal",
"federalisation",
"federalism",
"federalist",
"federalization",
"federation",
"federita",
"fedora",
"feebleness",
"feed",
"feedback",
"feedbag",
"feeder",
"feeding",
"feedlot",
"feedstock",
"feel",
"feeler",
"feeling",
"feelings",
"feifer",
"feigning",
"feijoa",
"feint",
"feist",
"felafel",
"feldene",
"feldspar",
"felicia",
"felicitation",
"felicitousness",
"felicity",
"felid",
"felidae",
"feline",
"felis",
"fell",
"fella",
"fellah",
"fellata",
"fellatio",
"fellation",
"feller",
"fellini",
"felloe",
"fellow",
"fellowship",
"felly",
"felon",
"felony",
"felspar",
"felt",
"felucca",
"felwort",
"fema",
"female",
"femaleness",
"feminine",
"feminineness",
"femininity",
"feminisation",
"feminism",
"feminist",
"feminization",
"femoris",
"femtochemistry",
"femtometer",
"femtometre",
"femtosecond",
"femtovolt",
"femur",
"fence",
"fencer",
"fencesitter",
"fencing",
"fender",
"fenestella",
"fenestra",
"fenestration",
"fengtien",
"fenland",
"fennel",
"fennic",
"fenoprofen",
"fenrir",
"fentanyl",
"fenugreek",
"fenusa",
"feoff",
"feosol",
"ferber",
"ferdinand",
"fergon",
"fergusonite",
"feria",
"fermat",
"fermata",
"ferment",
"fermentation",
"fermenting",
"fermentologist",
"fermi",
"fermion",
"fermium",
"fern",
"ferocactus",
"ferociousness",
"ferocity",
"ferrara",
"ferret",
"ferricyanide",
"ferrimagnetism",
"ferrite",
"ferritin",
"ferrocerium",
"ferroconcrete",
"ferrocyanide",
"ferromagnetism",
"ferrule",
"ferry",
"ferryboat",
"ferrying",
"ferryman",
"fertilisation",
"fertiliser",
"fertility",
"fertilization",
"fertilizer",
"ferule",
"fervency",
"fervidness",
"fervor",
"fervour",
"fescue",
"fess",
"fesse",
"fester",
"festering",
"festination",
"festival",
"festivity",
"festoon",
"festoonery",
"festschrift",
"festuca",
"fetch",
"fete",
"feterita",
"fetich",
"fetichism",
"feticide",
"fetidness",
"fetish",
"fetishism",
"fetishist",
"fetlock",
"fetology",
"fetometry",
"fetoprotein",
"fetor",
"fetoscope",
"fetoscopy",
"fetter",
"fetterbush",
"fettle",
"fettuccine",
"fettuccini",
"fetus",
"feud",
"feudalism",
"feudatory",
"fever",
"feverfew",
"feverishness",
"feverroot",
"fewness",
"feynman",
"fhlmc",
"fiance",
"fiancee",
"fiasco",
"fiat",
"fibber",
"fibbing",
"fiber",
"fiberboard",
"fiberglass",
"fiberoptics",
"fiberscope",
"fibre",
"fibreboard",
"fibreglass",
"fibreoptics",
"fibril",
"fibrillation",
"fibrin",
"fibrinase",
"fibrinogen",
"fibrinolysin",
"fibrinolysis",
"fibrinopeptide",
"fibroadenoma",
"fibroblast",
"fibrocartilage",
"fibroid",
"fibroma",
"fibromyositis",
"fibrosis",
"fibrositis",
"fibrosity",
"fibrousness",
"fibula",
"fica",
"fice",
"fichu",
"fickleness",
"fiction",
"ficus",
"fiddle",
"fiddlehead",
"fiddleneck",
"fiddler",
"fiddlestick",
"fidelity",
"fidget",
"fidgetiness",
"fiduciary",
"fiedler",
"fief",
"fiefdom",
"field",
"fielder",
"fieldfare",
"fieldhand",
"fielding",
"fieldmouse",
"fields",
"fieldsman",
"fieldstone",
"fieldwork",
"fieldworker",
"fiend",
"fierceness",
"fieriness",
"fiesta",
"fife",
"fifo",
"fifteen",
"fifteenth",
"fifth",
"fifties",
"fiftieth",
"fifty",
"figeater",
"fight",
"fighter",
"fighting",
"figment",
"figuration",
"figure",
"figurehead",
"figurer",
"figurine",
"figuring",
"figwort",
"fiji",
"fijian",
"fijis",
"filaggrin",
"filago",
"filagree",
"filament",
"filaree",
"filaria",
"filariasis",
"filariidae",
"filature",
"filbert",
"file",
"filefish",
"filename",
"filer",
"filet",
"filiation",
"filibuster",
"filibusterer",
"filicales",
"filicide",
"filicinae",
"filicopsida",
"filigree",
"filing",
"filipino",
"fill",
"fillagree",
"fille",
"filler",
"fillet",
"filling",
"fillip",
"fillmore",
"filly",
"film",
"filmdom",
"filming",
"filmmaker",
"filoviridae",
"filovirus",
"fils",
"filter",
"filth",
"filthiness",
"filtrate",
"filtration",
"filum",
"fimbria",
"finagler",
"final",
"finale",
"finalisation",
"finalist",
"finality",
"finalization",
"finance",
"finances",
"financier",
"financing",
"finback",
"fincen",
"finch",
"find",
"finder",
"finding",
"findings",
"fine",
"fineness",
"finery",
"finesse",
"finger",
"fingerboard",
"fingerbreadth",
"fingerflower",
"fingering",
"fingerling",
"fingermark",
"fingernail",
"fingerpaint",
"fingerpointing",
"fingerpost",
"fingerprint",
"fingerprinting",
"fingerroot",
"fingerspelling",
"fingerstall",
"fingertip",
"finial",
"finis",
"finish",
"finisher",
"finishing",
"finiteness",
"finitude",
"fink",
"finland",
"finn",
"finnan",
"finnbogadottir",
"finnic",
"finnish",
"finocchio",
"fiord",
"fipple",
"fire",
"firearm",
"fireball",
"firebase",
"firebird",
"fireboat",
"firebomb",
"firebox",
"firebrand",
"firebrat",
"firebreak",
"firebrick",
"firebug",
"fireclay",
"firecracker",
"firedamp",
"firedog",
"firedrake",
"firefighter",
"firefly",
"fireguard",
"firehouse",
"firelight",
"firelighter",
"firelock",
"fireman",
"firenze",
"fireplace",
"fireplug",
"firepower",
"fireroom",
"fireside",
"firestone",
"firestorm",
"firethorn",
"firetrap",
"firewall",
"firewater",
"fireweed",
"firewood",
"firework",
"firing",
"firkin",
"firm",
"firmament",
"firmiana",
"firmness",
"firmware",
"first",
"firstborn",
"firth",
"fisa",
"fisc",
"fischer",
"fish",
"fishbone",
"fishbowl",
"fisher",
"fisherman",
"fishery",
"fishgig",
"fishhook",
"fishing",
"fishmonger",
"fishnet",
"fishpaste",
"fishplate",
"fishpond",
"fishwife",
"fishworm",
"fission",
"fissiparity",
"fissiped",
"fissipedia",
"fissure",
"fissurella",
"fissurellidae",
"fist",
"fistfight",
"fistful",
"fisticuffs",
"fistmele",
"fistula",
"fistularia",
"fistulariidae",
"fistulina",
"fistulinaceae",
"fitch",
"fitfulness",
"fitment",
"fitness",
"fitter",
"fitting",
"fittingness",
"fitzgerald",
"five",
"fivepence",
"fiver",
"fives",
"fivesome",
"fixation",
"fixative",
"fixedness",
"fixer",
"fixing",
"fixings",
"fixity",
"fixture",
"fizgig",
"fizz",
"fizzle",
"fjord",
"flab",
"flabbiness",
"flaccidity",
"flack",
"flacourtia",
"flacourtiaceae",
"flag",
"flagellant",
"flagellata",
"flagellate",
"flagellation",
"flagellum",
"flageolet",
"flagfish",
"flagging",
"flagon",
"flagpole",
"flagroot",
"flagship",
"flagstaff",
"flagstone",
"flagyl",
"flail",
"flair",
"flak",
"flake",
"flakiness",
"flambeau",
"flamboyance",
"flamboyant",
"flame",
"flamefish",
"flameflower",
"flamen",
"flamenco",
"flamethrower",
"flaming",
"flamingo",
"flaminius",
"flammability",
"flammulina",
"flan",
"flanders",
"flange",
"flank",
"flanker",
"flannel",
"flannelbush",
"flannelette",
"flap",
"flapcake",
"flapjack",
"flapper",
"flapping",
"flaps",
"flare",
"flash",
"flashback",
"flashboard",
"flashboarding",
"flashbulb",
"flashcard",
"flasher",
"flashflood",
"flashgun",
"flashiness",
"flashing",
"flashlight",
"flashover",
"flashpoint",
"flask",
"flaskful",
"flat",
"flatbed",
"flatboat",
"flatbread",
"flatbrod",
"flatcar",
"flatfish",
"flatfoot",
"flathead",
"flatiron",
"flatlet",
"flatmate",
"flatness",
"flats",
"flatterer",
"flattery",
"flattop",
"flatulence",
"flatulency",
"flatus",
"flatware",
"flatwork",
"flatworm",
"flaubert",
"flaunt",
"flautist",
"flavin",
"flaviviridae",
"flavivirus",
"flavone",
"flavonoid",
"flavor",
"flavorer",
"flavoring",
"flavorlessness",
"flavorsomeness",
"flavour",
"flavourer",
"flavouring",
"flavourlessness",
"flavoursomeness",
"flaw",
"flawlessness",
"flax",
"flaxedil",
"flaxseed",
"flea",
"fleabag",
"fleabane",
"fleapit",
"fleawort",
"flecainide",
"fleck",
"flection",
"fledgeling",
"fledgling",
"fleece",
"fleer",
"fleet",
"fleetingness",
"fleetness",
"fleming",
"flemish",
"flesh",
"fleshiness",
"fletc",
"fletcher",
"flex",
"flexeril",
"flexibility",
"flexibleness",
"flexion",
"flexor",
"flexure",
"flibbertigibbet",
"flick",
"flicker",
"flickertail",
"flier",
"flies",
"flight",
"flightiness",
"flimflam",
"flimsiness",
"flimsy",
"flinch",
"flinders",
"flindersia",
"flindosa",
"flindosy",
"fling",
"flint",
"flinthead",
"flintlock",
"flintstone",
"flip",
"flippancy",
"flipper",
"flirt",
"flirtation",
"flirting",
"flit",
"flitch",
"flnc",
"float",
"floatation",
"floater",
"floating",
"floatplane",
"floc",
"flocculation",
"floccule",
"flock",
"flodden",
"floe",
"flogger",
"flogging",
"flood",
"floodgate",
"floodhead",
"flooding",
"floodlight",
"floodplain",
"floor",
"floorboard",
"flooring",
"floorshow",
"floorwalker",
"floozie",
"floozy",
"flop",
"flophouse",
"floppy",
"flora",
"floreal",
"florence",
"florentine",
"florescence",
"floret",
"florey",
"floriculture",
"florida",
"floridian",
"floridity",
"floridness",
"florilegium",
"florin",
"florio",
"florist",
"flory",
"floss",
"flotation",
"flotilla",
"flotsam",
"flounce",
"flounder",
"flour",
"flourish",
"flouter",
"flow",
"flowage",
"flowchart",
"flower",
"flowerbed",
"floweret",
"flowering",
"flowerpot",
"flowing",
"floxuridine",
"flub",
"fluctuation",
"flue",
"fluegelhorn",
"fluency",
"fluff",
"fluffiness",
"flugelhorn",
"fluid",
"fluidity",
"fluidness",
"fluidounce",
"fluidram",
"fluke",
"flume",
"flummery",
"flunitrazepan",
"flunk",
"flunkey",
"flunky",
"fluor",
"fluorapatite",
"fluorescein",
"fluoresceine",
"fluorescence",
"fluorescent",
"fluoridation",
"fluoride",
"fluoridisation",
"fluoridization",
"fluorine",
"fluorite",
"fluoroboride",
"fluorocarbon",
"fluorochrome",
"fluoroform",
"fluoroscope",
"fluoroscopy",
"fluorosis",
"fluorouracil",
"fluorspar",
"fluosilicate",
"fluoxetine",
"fluphenazine",
"flurazepam",
"flurbiprofen",
"flurry",
"flush",
"fluster",
"flute",
"fluting",
"flutist",
"flutter",
"fluttering",
"fluvastatin",
"flux",
"fluxion",
"fluxmeter",
"flybridge",
"flycatcher",
"flyer",
"flying",
"flyleaf",
"flyover",
"flypaper",
"flypast",
"flyspeck",
"flyswat",
"flyswatter",
"flytrap",
"flyway",
"flyweight",
"flywheel",
"fmri",
"fnma",
"foal",
"foam",
"foamflower",
"foaminess",
"focalisation",
"focalization",
"focus",
"focusing",
"focussing",
"fodder",
"foehn",
"foeman",
"foeniculum",
"foetology",
"foetometry",
"foetoprotein",
"foetor",
"foetoscope",
"foetoscopy",
"foetus",
"fogbank",
"fogey",
"fogginess",
"foghorn",
"foglamp",
"fogsignal",
"fogy",
"fohn",
"foible",
"foil",
"foiling",
"folacin",
"folate",
"fold",
"folder",
"folderal",
"folderol",
"folding",
"foldout",
"foliage",
"foliation",
"folie",
"folio",
"folium",
"folk",
"folklore",
"folks",
"folksong",
"folktale",
"follicle",
"folliculitis",
"follies",
"follower",
"followers",
"following",
"followup",
"folly",
"fomentation",
"fomenter",
"fomes",
"fomite",
"fomor",
"fomorian",
"fonda",
"fondant",
"fondler",
"fondling",
"fondness",
"fondu",
"fondue",
"font",
"fontanel",
"fontanelle",
"fontanne",
"fontenoy",
"fonteyn",
"food",
"foodie",
"foodstuff",
"fool",
"foolery",
"foolhardiness",
"foolishness",
"foolscap",
"foot",
"footage",
"football",
"footballer",
"footbath",
"footboard",
"footbridge",
"footcandle",
"footedness",
"footer",
"footfall",
"footfault",
"footgear",
"foothill",
"foothold",
"footing",
"footlights",
"footlocker",
"footman",
"footmark",
"footnote",
"footpad",
"footpath",
"footplate",
"footprint",
"footrace",
"footrest",
"footslogger",
"footstall",
"footstep",
"footstool",
"footwall",
"footwear",
"footwork",
"foppishness",
"forage",
"forager",
"foraging",
"foram",
"foramen",
"foraminifer",
"foraminifera",
"foray",
"forbear",
"forbearance",
"forbiddance",
"forbidding",
"force",
"forcefulness",
"forcemeat",
"forceps",
"ford",
"fordhooks",
"fording",
"fore",
"forearm",
"forebear",
"foreboding",
"forebrain",
"forecast",
"forecaster",
"forecasting",
"forecastle",
"foreclosure",
"forecourt",
"foredeck",
"foredge",
"forefather",
"forefinger",
"forefoot",
"forefront",
"foreground",
"foregrounding",
"forehand",
"forehead",
"foreigner",
"foreignness",
"foreknowledge",
"forelady",
"foreland",
"foreleg",
"forelimb",
"forelock",
"foreman",
"foremanship",
"foremast",
"foremilk",
"foremother",
"forename",
"forenoon",
"forensics",
"foreordination",
"forepart",
"forepaw",
"foreperson",
"foreplay",
"forequarter",
"forerunner",
"foresail",
"foreshadowing",
"foreshank",
"foreshock",
"foreshore",
"foresight",
"foresightedness",
"foreskin",
"forest",
"forestage",
"forestalling",
"forestay",
"forester",
"forestiera",
"forestry",
"foretaste",
"foretelling",
"forethought",
"foretoken",
"foretop",
"forewarning",
"forewing",
"forewoman",
"foreword",
"forfeit",
"forfeiture",
"forficula",
"forficulidae",
"forge",
"forger",
"forgery",
"forgetfulness",
"forging",
"forgiveness",
"forgiver",
"forgivingness",
"forgoing",
"forint",
"fork",
"forking",
"forklift",
"forlornness",
"form",
"formal",
"formaldehyde",
"formalin",
"formalisation",
"formalism",
"formalities",
"formality",
"formalization",
"formalness",
"formalwear",
"format",
"formation",
"formative",
"formatting",
"former",
"formica",
"formicariidae",
"formicarius",
"formicary",
"formication",
"formicidae",
"formidability",
"formol",
"formosa",
"formosan",
"formula",
"formulary",
"formulation",
"fornax",
"fornication",
"fornicator",
"fornicatress",
"fornix",
"forsaking",
"forseti",
"forswearing",
"forsythia",
"fort",
"fortaz",
"forte",
"forth",
"forthcomingness",
"forthrightness",
"forties",
"fortieth",
"fortification",
"fortissimo",
"fortitude",
"fortnight",
"fortran",
"fortress",
"fortuitousness",
"fortuity",
"fortuna",
"fortune",
"fortunella",
"fortuneteller",
"fortunetelling",
"forty",
"forum",
"forward",
"forwarding",
"forwardness",
"foryml",
"fosamax",
"fosbury",
"fossa",
"fosse",
"fossil",
"fossilisation",
"fossilist",
"fossilization",
"fossilology",
"foster",
"fosterage",
"fostering",
"fosterling",
"fothergilla",
"fots",
"foucault",
"foul",
"foulard",
"foulmart",
"foulness",
"foumart",
"found",
"foundation",
"founder",
"foundering",
"founding",
"foundling",
"foundress",
"foundry",
"fount",
"fountain",
"fountainhead",
"fouquieria",
"fouquieriaceae",
"four",
"fourier",
"fourpence",
"fourscore",
"foursome",
"foursquare",
"fourteen",
"fourteenth",
"fourth",
"fovea",
"fowl",
"fowler",
"foxberry",
"foxglove",
"foxhole",
"foxhound",
"foxhunt",
"foxiness",
"foxtail",
"foxtrot",
"foyer",
"fracas",
"fractal",
"fraction",
"fractionation",
"fractiousness",
"fracture",
"fradicin",
"fragaria",
"fragility",
"fragment",
"fragmentation",
"fragonard",
"fragrance",
"fragrancy",
"frail",
"frailness",
"frailty",
"fraise",
"frambesia",
"framboesia",
"framboise",
"frame",
"framer",
"framework",
"framing",
"franc",
"france",
"franchise",
"franciscan",
"francisella",
"francium",
"franck",
"franco",
"francoa",
"francophil",
"francophile",
"francophobe",
"frangibility",
"frangibleness",
"frangipane",
"frangipani",
"frangipanni",
"frank",
"frankenstein",
"frankfort",
"frankfurt",
"frankfurter",
"frankincense",
"franklin",
"frankliniella",
"frankness",
"frappe",
"frasera",
"frat",
"fratercula",
"fraternisation",
"fraternity",
"fraternization",
"fratricide",
"frau",
"fraud",
"fraudulence",
"fraulein",
"fraxinella",
"fraxinus",
"fray",
"frazer",
"frazzle",
"freak",
"freakishness",
"freckle",
"frederick",
"fredericksburg",
"fredericton",
"free",
"freebee",
"freebie",
"freebooter",
"freedman",
"freedom",
"freedwoman",
"freehold",
"freeholder",
"freeing",
"freelance",
"freelancer",
"freeloader",
"freemail",
"freeman",
"freemason",
"freemasonry",
"freesia",
"freestone",
"freestyle",
"freetail",
"freethinker",
"freethinking",
"freetown",
"freeware",
"freeway",
"freewheel",
"freewheeler",
"freewoman",
"freeze",
"freezer",
"freezing",
"fregata",
"fregatidae",
"freight",
"freightage",
"freighter",
"fremont",
"fremontia",
"fremontodendron",
"french",
"frenchman",
"frenchwoman",
"frenzy",
"freon",
"frequence",
"frequency",
"frequentative",
"frequenter",
"fresco",
"freshener",
"fresher",
"freshet",
"freshman",
"freshness",
"freshwater",
"fresnel",
"fresno",
"fret",
"fretfulness",
"fretsaw",
"fretwork",
"freud",
"freudian",
"frey",
"freya",
"freyja",
"freyr",
"friability",
"friar",
"friary",
"fricandeau",
"fricassee",
"fricative",
"frick",
"friction",
"friday",
"fridge",
"friedan",
"friedcake",
"friedman",
"friend",
"friendlessness",
"friendliness",
"friendly",
"friendship",
"frier",
"fries",
"friesian",
"friesland",
"frieze",
"frigate",
"frigg",
"frigga",
"fright",
"frightening",
"frightfulness",
"frigidity",
"frigidness",
"frijol",
"frijole",
"frijolillo",
"frijolito",
"frill",
"frimaire",
"fringe",
"fringepod",
"fringilla",
"fringillidae",
"frippery",
"frisbee",
"frisch",
"frisia",
"frisian",
"frisk",
"friskiness",
"frisking",
"frisson",
"fritillaria",
"fritillary",
"frittata",
"fritter",
"friuli",
"friulian",
"frivolity",
"frivolousness",
"frizz",
"frobisher",
"frock",
"froebel",
"froelichia",
"frog",
"frogbit",
"frogfish",
"froghopper",
"frogman",
"frogmouth",
"frolic",
"frolicsomeness",
"frond",
"front",
"frontage",
"frontal",
"frontbencher",
"frontier",
"frontiersman",
"frontierswoman",
"frontispiece",
"frontlet",
"frontstall",
"frost",
"frostbite",
"frostiness",
"frosting",
"frostweed",
"frostwort",
"froth",
"frothiness",
"frottage",
"frotteur",
"frown",
"fructidor",
"fructification",
"fructose",
"fructosuria",
"frugality",
"frugalness",
"fruit",
"fruitage",
"fruitcake",
"fruiterer",
"fruitfulness",
"fruition",
"fruitlessness",
"fruitlet",
"fruitwood",
"frumenty",
"frump",
"frunze",
"frustration",
"frustum",
"frye",
"fryer",
"frying",
"frypan",
"fthm",
"fucaceae",
"fucales",
"fuchs",
"fuchsia",
"fuck",
"fucker",
"fuckhead",
"fucking",
"fuckup",
"fucoid",
"fucus",
"fuddle",
"fudge",
"fuego",
"fuel",
"fueling",
"fuentes",
"fugaciousness",
"fugacity",
"fugard",
"fugitive",
"fugleman",
"fugo",
"fugu",
"fugue",
"fuji",
"fujinoyama",
"fujiyama",
"fukien",
"fukkianese",
"fukuoka",
"fula",
"fulah",
"fulani",
"fulbe",
"fulbright",
"fulcrum",
"fulfillment",
"fulfilment",
"fulgoridae",
"fulica",
"full",
"fullback",
"fuller",
"fullerene",
"fullness",
"fulmar",
"fulmarus",
"fulminate",
"fulmination",
"fulsomeness",
"fulton",
"fulvicin",
"fumaria",
"fumariaceae",
"fumble",
"fumbler",
"fume",
"fumeroot",
"fumes",
"fumewort",
"fumigant",
"fumigation",
"fumigator",
"fumitory",
"funafuti",
"funambulism",
"funambulist",
"function",
"functionalism",
"functionalist",
"functionality",
"functionary",
"functioning",
"fund",
"fundament",
"fundamental",
"fundamentalism",
"fundamentalist",
"fundamentals",
"funding",
"fundraiser",
"funds",
"fundulus",
"fundus",
"funeral",
"funfair",
"fungi",
"fungia",
"fungibility",
"fungible",
"fungicide",
"fungus",
"funicle",
"funicular",
"funiculitis",
"funiculus",
"funk",
"funka",
"funkaceae",
"funnel",
"funnies",
"funniness",
"funny",
"funrun",
"fuqra",
"furan",
"furane",
"furbelow",
"furcation",
"furcula",
"furfural",
"furfuraldehyde",
"furfuran",
"furiousness",
"furlong",
"furlough",
"furnace",
"furnariidae",
"furnarius",
"furnishing",
"furniture",
"furnivall",
"furor",
"furore",
"furosemide",
"furrier",
"furring",
"furrow",
"furtherance",
"furtiveness",
"furuncle",
"furunculosis",
"fury",
"furze",
"fusain",
"fusanus",
"fuschia",
"fuscoboletinus",
"fuse",
"fusee",
"fuselage",
"fusil",
"fusilier",
"fusillade",
"fusion",
"fuss",
"fussiness",
"fusspot",
"fustian",
"futility",
"futon",
"future",
"futurism",
"futurist",
"futuristics",
"futurity",
"futurology",
"fuze",
"fuzee",
"fuzz",
"fuzziness",
"gaap",
"gaba",
"gabapentin",
"gabardine",
"gabble",
"gabbro",
"gaberdine",
"gabfest",
"gable",
"gabon",
"gabonese",
"gabor",
"gaboriau",
"gaborone",
"gabriel",
"gabun",
"gadaba",
"gadabout",
"gaddafi",
"gaddi",
"gadfly",
"gadget",
"gadgeteer",
"gadgetry",
"gadidae",
"gadiformes",
"gadoid",
"gadolinite",
"gadolinium",
"gadsden",
"gadus",
"gaea",
"gael",
"gaelic",
"gaff",
"gaffe",
"gaffer",
"gaffsail",
"gafsa",
"gagarin",
"gage",
"gaggle",
"gagman",
"gagster",
"gagwriter",
"gaia",
"gaiety",
"gaillardia",
"gain",
"gainer",
"gainesville",
"gainfulness",
"gainsborough",
"gaiseric",
"gait",
"gaiter",
"gaius",
"gala",
"galactagogue",
"galactocele",
"galactose",
"galactosemia",
"galactosis",
"galago",
"galahad",
"galan",
"galangal",
"galantine",
"galapagos",
"galatea",
"galatia",
"galatian",
"galatians",
"galax",
"galaxy",
"galbanum",
"galbraith",
"galbulidae",
"galbulus",
"gale",
"galea",
"galega",
"galen",
"galena",
"galeocerdo",
"galeopsis",
"galeorhinus",
"galeras",
"galere",
"galicia",
"galician",
"galilaean",
"galilean",
"galilee",
"galileo",
"galingale",
"galium",
"gall",
"gallamine",
"gallant",
"gallantry",
"gallaudet",
"gallberry",
"gallbladder",
"galleon",
"galleria",
"gallery",
"galley",
"gallfly",
"gallia",
"galliano",
"gallicanism",
"gallicism",
"galliformes",
"gallimaufry",
"gallina",
"gallinacean",
"gallinago",
"gallinula",
"gallinule",
"gallirallus",
"gallium",
"gallon",
"gallop",
"gallous",
"galloway",
"gallows",
"gallstone",
"gallup",
"gallus",
"galois",
"galoot",
"galosh",
"galsworthy",
"galton",
"galvani",
"galvanisation",
"galvaniser",
"galvanism",
"galvanization",
"galvanizer",
"galvanometer",
"galveston",
"galway",
"gamba",
"gambelia",
"gambia",
"gambian",
"gambist",
"gambit",
"gamble",
"gambler",
"gambling",
"gamboge",
"gambol",
"gambrel",
"gambusia",
"game",
"gamebag",
"gameboard",
"gamecock",
"gamekeeper",
"gamelan",
"gameness",
"gamesmanship",
"gametangium",
"gamete",
"gametocyte",
"gametoecium",
"gametogenesis",
"gametophore",
"gametophyte",
"gamin",
"gamine",
"gaminess",
"gaming",
"gamma",
"gammon",
"gammopathy",
"gamow",
"gamp",
"gamut",
"ganapati",
"gand",
"gander",
"gandhi",
"ganef",
"ganesa",
"ganesh",
"ganesha",
"gang",
"gangboard",
"gangdom",
"ganger",
"ganges",
"gangland",
"gangliocyte",
"ganglion",
"gangplank",
"gangrene",
"gangsaw",
"gangsta",
"gangster",
"gangway",
"ganja",
"gannet",
"ganof",
"ganoid",
"ganoidei",
"ganoin",
"ganoine",
"gansu",
"gantanol",
"gantlet",
"gantrisin",
"gantry",
"ganymede",
"gaol",
"gaolbird",
"gaolbreak",
"gaoler",
"gape",
"garage",
"garambulla",
"garamycin",
"garand",
"garb",
"garbage",
"garbageman",
"garbanzo",
"garbo",
"garboard",
"garboil",
"garbology",
"garcinia",
"garden",
"gardener",
"gardenia",
"gardening",
"gardiner",
"gardner",
"garfield",
"garfish",
"garganey",
"gargantua",
"garget",
"gargle",
"gargoyle",
"gargoylism",
"gari",
"garibaldi",
"garishness",
"garland",
"garlic",
"garment",
"garmentmaker",
"garner",
"garnet",
"garnier",
"garnierite",
"garnish",
"garnishee",
"garnishment",
"garonne",
"garotte",
"garpike",
"garret",
"garrick",
"garrison",
"garrote",
"garroter",
"garrotte",
"garrotter",
"garrulinae",
"garrulity",
"garrulousness",
"garrulus",
"garter",
"garuda",
"gary",
"gasbag",
"gascogne",
"gasconade",
"gascony",
"gaseousness",
"gasfield",
"gash",
"gasherbrum",
"gasification",
"gaskell",
"gasket",
"gaskin",
"gaslight",
"gasman",
"gasmask",
"gasohol",
"gasolene",
"gasoline",
"gasometer",
"gasp",
"gaspar",
"gassing",
"gasteromycete",
"gasteromycetes",
"gasterophilidae",
"gasterophilus",
"gasteropoda",
"gasterosteidae",
"gasterosteus",
"gastralgia",
"gastrectomy",
"gastrin",
"gastritis",
"gastroboletus",
"gastrocnemius",
"gastrocybe",
"gastroenteritis",
"gastrogavage",
"gastrolobium",
"gastromy",
"gastromycete",
"gastromycetes",
"gastronome",
"gastronomy",
"gastrophryne",
"gastropod",
"gastropoda",
"gastroscope",
"gastroscopy",
"gastrostomy",
"gastrula",
"gastrulation",
"gasworks",
"gate",
"gateau",
"gatecrasher",
"gatefold",
"gatehouse",
"gatekeeper",
"gatepost",
"gates",
"gateway",
"gather",
"gatherer",
"gathering",
"gathic",
"gatling",
"gator",
"gatt",
"gaucheness",
"gaucherie",
"gaucho",
"gaud",
"gaudery",
"gaudi",
"gaudiness",
"gaudy",
"gauffer",
"gauge",
"gauguin",
"gaul",
"gaultheria",
"gauntlet",
"gauntness",
"gauntry",
"gaur",
"gauri",
"gauss",
"gaussmeter",
"gautama",
"gauze",
"gavage",
"gavel",
"gavia",
"gavial",
"gavialidae",
"gavialis",
"gavidae",
"gaviiformes",
"gavotte",
"gawain",
"gawk",
"gawker",
"gawkiness",
"gayal",
"gayfeather",
"gaylussacia",
"gayness",
"gaywings",
"gaza",
"gazania",
"gaze",
"gazebo",
"gazella",
"gazelle",
"gazette",
"gazetteer",
"gazillion",
"gazpacho",
"gbit",
"gcse",
"gdansk",
"gean",
"gear",
"gearbox",
"gearing",
"gearset",
"gearshift",
"gearstick",
"geartrain",
"geastraceae",
"geastrum",
"gecko",
"geebung",
"geek",
"geezer",
"geezerhood",
"gegenschein",
"geglossaceae",
"gehenna",
"gehrig",
"geiger",
"geisel",
"geisha",
"gekkonidae",
"gelatin",
"gelatine",
"gelatinousness",
"gelding",
"gelechia",
"gelechiid",
"gelechiidae",
"gelidity",
"gelignite",
"gelly",
"gelsemium",
"gelt",
"gemara",
"gemfibrozil",
"geminate",
"gemination",
"gemini",
"gemma",
"gemmation",
"gemmule",
"gemonil",
"gempylid",
"gempylidae",
"gempylus",
"gemsbok",
"gemsbuck",
"gemstone",
"gendarme",
"gendarmerie",
"gendarmery",
"gender",
"gene",
"genealogist",
"genealogy",
"general",
"generalcy",
"generalisation",
"generalissimo",
"generalist",
"generality",
"generalization",
"generalship",
"generation",
"generator",
"generic",
"generosity",
"generousness",
"genesis",
"genet",
"geneticism",
"geneticist",
"genetics",
"genetta",
"geneva",
"genevan",
"geneve",
"genf",
"geniality",
"genie",
"genip",
"genipa",
"genipap",
"genista",
"genitalia",
"genitals",
"genitive",
"genitor",
"genius",
"genlisea",
"genoa",
"genocide",
"genoese",
"genoise",
"genome",
"genomics",
"genotype",
"genova",
"genre",
"gens",
"genseric",
"gent",
"gentamicin",
"genteelness",
"gentian",
"gentiana",
"gentianaceae",
"gentianales",
"gentianella",
"gentianopsis",
"gentile",
"gentility",
"gentlefolk",
"gentleman",
"gentleness",
"gentlewoman",
"gentrification",
"gentry",
"genu",
"genuflection",
"genuflexion",
"genuineness",
"genus",
"genyonemus",
"geochelone",
"geochemistry",
"geococcyx",
"geode",
"geodesic",
"geodesy",
"geoduck",
"geoffroea",
"geoglossaceae",
"geoglossum",
"geographer",
"geographics",
"geography",
"geologist",
"geology",
"geomancer",
"geomancy",
"geometer",
"geometrician",
"geometrid",
"geometridae",
"geometry",
"geomorphology",
"geomyidae",
"geomys",
"geophagia",
"geophagy",
"geophilidae",
"geophilomorpha",
"geophilus",
"geophysicist",
"geophysics",
"geophyte",
"geopolitics",
"geordie",
"george",
"georgetown",
"georgette",
"georgia",
"georgian",
"geosphere",
"geostrategy",
"geothlypis",
"geotropism",
"geraint",
"geraniaceae",
"geraniales",
"geranium",
"gerardia",
"gerbera",
"gerbert",
"gerbil",
"gerbille",
"gerbillinae",
"gerbillus",
"gerea",
"gerenuk",
"gerfalcon",
"geriatrician",
"geriatrics",
"germ",
"german",
"germander",
"germaneness",
"germanic",
"germanism",
"germanist",
"germanite",
"germanium",
"germany",
"germicide",
"germinal",
"germination",
"geronimo",
"gerontocracy",
"gerontologist",
"gerontology",
"gerreidae",
"gerres",
"gerrhonotus",
"gerridae",
"gerrididae",
"gerris",
"gerrymander",
"gershwin",
"gerund",
"geryon",
"gesell",
"gesner",
"gesneria",
"gesneriaceae",
"gesneriad",
"gesso",
"gestalt",
"gestapo",
"gestation",
"gesticulation",
"gesture",
"geta",
"getaway",
"getting",
"gettysburg",
"getup",
"geum",
"gewgaw",
"geyser",
"ghana",
"ghanian",
"gharry",
"ghastliness",
"ghat",
"ghatti",
"ghee",
"gheg",
"ghent",
"gherkin",
"ghetto",
"ghillie",
"ghost",
"ghostfish",
"ghostliness",
"ghostwriter",
"ghoul",
"ghrelin",
"ghrf",
"giacometti",
"giant",
"giantess",
"giantism",
"giardia",
"giardiasis",
"gibber",
"gibberellin",
"gibberish",
"gibbet",
"gibbon",
"gibbosity",
"gibbousness",
"gibbs",
"gibbsite",
"gibe",
"gibibit",
"gibibyte",
"gibit",
"giblet",
"giblets",
"gibraltar",
"gibraltarian",
"gibran",
"gibson",
"gidar",
"giddiness",
"gide",
"gidgee",
"gielgud",
"gift",
"gigabit",
"gigabyte",
"gigacycle",
"gigahertz",
"gigantism",
"gigartinaceae",
"giggle",
"giggler",
"gigo",
"gigolo",
"gigot",
"gigue",
"gikuyu",
"gila",
"gilbert",
"gild",
"gilder",
"gildhall",
"gilding",
"gilgamesh",
"gilgamish",
"gill",
"gillespie",
"gillette",
"gillie",
"gillyflower",
"gilman",
"gilmer",
"gilt",
"gimbal",
"gimcrack",
"gimcrackery",
"gimel",
"gimlet",
"gimmick",
"gimmickry",
"gimp",
"gimpiness",
"ginep",
"ginger",
"gingerbread",
"gingerol",
"gingerroot",
"gingersnap",
"gingham",
"gingiva",
"gingivitis",
"gingko",
"ginglymostoma",
"ginglymus",
"ginkgo",
"ginkgoaceae",
"ginkgoales",
"ginkgophytina",
"ginkgopsida",
"ginmill",
"ginsberg",
"ginseng",
"ginzo",
"giotto",
"gipsy",
"gipsywort",
"giraffa",
"giraffe",
"giraffidae",
"girandola",
"girandole",
"girard",
"girasol",
"giraudoux",
"girder",
"girdle",
"giriama",
"girl",
"girlfriend",
"girlhood",
"girlishness",
"giro",
"gironde",
"girondin",
"girondism",
"girondist",
"girru",
"girth",
"gish",
"gismo",
"gist",
"gita",
"gitana",
"gitano",
"gittern",
"give",
"giveaway",
"given",
"givenness",
"giver",
"giving",
"giza",
"gizeh",
"gizmo",
"gizzard",
"gjellerup",
"glabella",
"glaciation",
"glacier",
"glad",
"gladdon",
"glade",
"gladfulness",
"gladiator",
"gladiola",
"gladiolus",
"gladness",
"gladsomeness",
"gladstone",
"glamor",
"glamorisation",
"glamorization",
"glamour",
"glamourisation",
"glamourization",
"glance",
"gland",
"glanders",
"glans",
"glare",
"glareola",
"glareole",
"glareolidae",
"glaser",
"glasgow",
"glasnost",
"glass",
"glassblower",
"glasses",
"glassful",
"glasshouse",
"glassmaker",
"glassware",
"glasswork",
"glassworker",
"glassworks",
"glasswort",
"glaswegian",
"glaucium",
"glaucoma",
"glaucomys",
"glauconite",
"glaux",
"glaze",
"glazer",
"glazier",
"gleam",
"gleaming",
"gleaner",
"gleba",
"glebe",
"glechoma",
"gleditsia",
"glee",
"gleefulness",
"gleet",
"gleichenia",
"gleicheniaceae",
"glen",
"glendower",
"glengarry",
"glenn",
"glia",
"glibness",
"glide",
"glider",
"gliding",
"glimmer",
"glimmering",
"glimpse",
"glinka",
"glint",
"glioblastoma",
"glioma",
"glipizide",
"gliricidia",
"gliridae",
"glis",
"glissade",
"glissando",
"glisten",
"glister",
"glitch",
"glitter",
"glitz",
"gloam",
"gloaming",
"gloat",
"gloating",
"glob",
"globalisation",
"globalization",
"globe",
"globefish",
"globeflower",
"globetrotter",
"globicephala",
"globigerina",
"globigerinidae",
"globin",
"globosity",
"globularness",
"globule",
"globulin",
"glochid",
"glochidium",
"glockenspiel",
"glogg",
"glomerule",
"glomerulus",
"gloom",
"gloominess",
"glop",
"glorification",
"gloriole",
"gloriosa",
"glory",
"gloss",
"glossa",
"glossalgia",
"glossarist",
"glossary",
"glossina",
"glossiness",
"glossinidae",
"glossitis",
"glossodia",
"glossodynia",
"glossolalia",
"glossopsitta",
"glossoptosis",
"glossy",
"glottis",
"gloucester",
"gloucestershire",
"glove",
"glow",
"glower",
"glowing",
"glowworm",
"gloxinia",
"glucagon",
"glucinium",
"gluck",
"glucocorticoid",
"glucophage",
"glucosamine",
"glucose",
"glucoside",
"glucosuria",
"glucotrol",
"glue",
"glueyness",
"gluiness",
"glume",
"glumness",
"gluon",
"glut",
"glutamate",
"glutamine",
"glute",
"glutelin",
"gluten",
"glutethimide",
"gluteus",
"glutinosity",
"glutinousness",
"glutton",
"gluttony",
"glyburide",
"glyceraldehyde",
"glyceria",
"glyceride",
"glycerin",
"glycerine",
"glycerite",
"glycerogel",
"glycerogelatin",
"glycerol",
"glycerole",
"glyceryl",
"glycine",
"glycogen",
"glycogenesis",
"glycol",
"glycolysis",
"glycoprotein",
"glycoside",
"glycosuria",
"glycyrrhiza",
"glyoxaline",
"glyph",
"glyptics",
"glyptography",
"gnaphalium",
"gnarl",
"gnat",
"gnatcatcher",
"gnathion",
"gnathostomata",
"gnathostome",
"gnawer",
"gneiss",
"gnetaceae",
"gnetales",
"gnetophyta",
"gnetophytina",
"gnetopsida",
"gnetum",
"gnocchi",
"gnome",
"gnomon",
"gnosis",
"gnostic",
"gnosticism",
"goad",
"goading",
"goal",
"goalie",
"goalkeeper",
"goalmouth",
"goalpost",
"goaltender",
"goat",
"goatee",
"goatfish",
"goatherd",
"goatsbeard",
"goatsfoot",
"goatskin",
"goatsucker",
"gobbet",
"gobble",
"gobbledygook",
"gobbler",
"gobi",
"gobiesocidae",
"gobiesox",
"gobiidae",
"gobio",
"goblet",
"goblin",
"gobs",
"goby",
"godard",
"godchild",
"goddard",
"goddaughter",
"goddess",
"godel",
"godfather",
"godhead",
"godiva",
"godlessness",
"godliness",
"godmother",
"godown",
"godparent",
"godsend",
"godson",
"godspeed",
"godunov",
"godwit",
"goebbels",
"goer",
"goering",
"goeteborg",
"goethals",
"goethe",
"goethite",
"gofer",
"goffer",
"goggles",
"gogh",
"gogol",
"goidelic",
"going",
"goiter",
"goitre",
"goitrogen",
"golan",
"golconda",
"gold",
"goldbeater",
"goldberg",
"goldbrick",
"goldbricking",
"goldcrest",
"goldcup",
"goldenbush",
"goldeneye",
"goldenrod",
"goldenseal",
"goldfield",
"goldfields",
"goldfinch",
"goldfish",
"goldilocks",
"golding",
"goldman",
"goldmark",
"goldmine",
"goldoni",
"goldsboro",
"goldsmith",
"goldstone",
"goldthread",
"goldworker",
"goldwyn",
"golem",
"golf",
"golfcart",
"golfclub",
"golfer",
"golfing",
"golgi",
"golgotha",
"goliard",
"goliath",
"golliwog",
"golliwogg",
"golosh",
"goma",
"gombrowicz",
"gomel",
"gomorrah",
"gomorrha",
"gompers",
"gomphothere",
"gomphotheriidae",
"gomphotherium",
"gomphrena",
"gomuti",
"gonad",
"gonadotrophin",
"gonadotropin",
"goncourt",
"gond",
"gondi",
"gondola",
"gondolier",
"gondoliere",
"gondwanaland",
"goner",
"gong",
"gongora",
"gongorism",
"gongorist",
"gonif",
"goniff",
"goniometer",
"gonion",
"goniopteris",
"gonioscopy",
"gonne",
"gonococcus",
"gonorhynchidae",
"gonorhynchus",
"gonorrhea",
"gonorrhoea",
"goober",
"good",
"goodall",
"goodby",
"goodbye",
"goodenia",
"goodeniaceae",
"goodman",
"goodness",
"goodwill",
"goody",
"goodyear",
"goodyera",
"goof",
"goofball",
"goofy",
"google",
"googly",
"googol",
"googolplex",
"gook",
"goon",
"gooney",
"goonie",
"goony",
"goop",
"goosander",
"goose",
"gooseberry",
"goosebump",
"goosefish",
"gooseflesh",
"goosefoot",
"gooseneck",
"gopher",
"gopherus",
"gopherwood",
"goral",
"gorbachev",
"gordimer",
"gordius",
"gore",
"gorgas",
"gorge",
"gorger",
"gorgerin",
"gorget",
"gorgon",
"gorgonacea",
"gorgoniacea",
"gorgonian",
"gorgonocephalus",
"gorgonzola",
"gorilla",
"goring",
"gorki",
"gorkiy",
"gorky",
"gorse",
"gosainthan",
"goshawk",
"gosling",
"gosmore",
"gospel",
"gospeler",
"gospeller",
"gospels",
"gossamer",
"gossip",
"gossiper",
"gossiping",
"gossipmonger",
"gossipmongering",
"gossypium",
"goteborg",
"goth",
"gothenburg",
"gothic",
"gothite",
"gotterdammerung",
"gouache",
"gouda",
"goudy",
"gouge",
"gouger",
"goujon",
"goulash",
"gould",
"gounod",
"gourd",
"gourde",
"gourmand",
"gourmandism",
"gourmandizer",
"gourmet",
"gout",
"governance",
"governed",
"governess",
"governing",
"government",
"governor",
"governorship",
"gown",
"goya",
"grab",
"grabber",
"grace",
"gracefulness",
"gracelessness",
"gracie",
"gracilariid",
"gracilariidae",
"gracility",
"gracillariidae",
"graciousness",
"grackle",
"gracula",
"grad",
"gradation",
"grade",
"grader",
"gradient",
"grading",
"gradual",
"graduality",
"gradualness",
"graduate",
"graduation",
"graecophile",
"graf",
"graffiti",
"graffito",
"graft",
"grafting",
"graham",
"grahame",
"grail",
"grain",
"grainfield",
"grainger",
"graininess",
"graining",
"gram",
"grama",
"gramicidin",
"graminaceae",
"graminales",
"gramineae",
"gramma",
"grammar",
"grammarian",
"grammatolatry",
"grammatophyllum",
"gramme",
"gramophone",
"gramps",
"grampus",
"gran",
"granada",
"granadilla",
"granadillo",
"granary",
"grand",
"grandad",
"grandaunt",
"grandchild",
"granddad",
"granddaddy",
"granddaughter",
"grandee",
"grandeur",
"grandfather",
"grandiloquence",
"grandiosity",
"grandma",
"grandmaster",
"grandmother",
"grandnephew",
"grandness",
"grandniece",
"grandpa",
"grandparent",
"grandson",
"grandstand",
"grandstander",
"granduncle",
"grange",
"granger",
"granicus",
"granite",
"graniteware",
"grannie",
"granny",
"granola",
"grant",
"grantee",
"granter",
"granth",
"grantor",
"granularity",
"granulation",
"granule",
"granulocyte",
"granuloma",
"grape",
"grapefruit",
"grapeshot",
"grapevine",
"graph",
"grapheme",
"graphic",
"graphics",
"graphite",
"graphologist",
"graphology",
"graphospasm",
"grapnel",
"grapo",
"grappa",
"grappelli",
"grapple",
"grappler",
"grappling",
"graptophyllum",
"grasp",
"grasping",
"grass",
"grassfinch",
"grassfire",
"grasshopper",
"grassland",
"grate",
"gratefulness",
"grater",
"graticule",
"gratification",
"grating",
"gratitude",
"gratuity",
"grave",
"gravedigger",
"gravel",
"gravelweed",
"graveness",
"graver",
"graverobber",
"graves",
"gravestone",
"graveyard",
"gravida",
"gravidation",
"gravidity",
"gravidness",
"gravimeter",
"gravimetry",
"gravitas",
"gravitation",
"graviton",
"gravity",
"gravure",
"gravy",
"gray",
"grayback",
"graybeard",
"grayhen",
"graylag",
"grayness",
"graz",
"graze",
"grazier",
"grazing",
"grease",
"greaseball",
"greasepaint",
"greaser",
"greasewood",
"greasiness",
"great",
"greatcoat",
"greatness",
"greave",
"greaves",
"grebe",
"grecian",
"greco",
"greece",
"greed",
"greediness",
"greegree",
"greek",
"greeley",
"green",
"greenback",
"greenbelt",
"greenberg",
"greenbottle",
"greenbrier",
"greene",
"greenery",
"greeneye",
"greenfly",
"greengage",
"greengrocer",
"greengrocery",
"greenhood",
"greenhorn",
"greenhouse",
"greening",
"greenishness",
"greenland",
"greenling",
"greenmail",
"greenmarket",
"greenness",
"greenockite",
"greenpeace",
"greenroom",
"greens",
"greensand",
"greensboro",
"greenshank",
"greensickness",
"greenskeeper",
"greensward",
"greenville",
"greenway",
"greenweed",
"greenwich",
"greenwing",
"greenwood",
"greeter",
"greeting",
"gregarine",
"gregarinida",
"gregariousness",
"gregory",
"greisen",
"gremlin",
"grenada",
"grenade",
"grenadian",
"grenadier",
"grenadine",
"grenoble",
"gresham",
"gretzky",
"grevillea",
"grewia",
"grey",
"greyback",
"greybeard",
"greyhen",
"greyhound",
"greylag",
"greyness",
"grias",
"grid",
"griddle",
"griddlecake",
"gridiron",
"gridlock",
"grief",
"grieg",
"grievance",
"griever",
"griffin",
"griffith",
"griffon",
"grifter",
"grigri",
"grill",
"grille",
"grilling",
"grillroom",
"grillwork",
"grimace",
"grime",
"griminess",
"grimm",
"grimness",
"grimoire",
"grin",
"grind",
"grindelia",
"grinder",
"grinding",
"grindle",
"grindstone",
"gringo",
"grinner",
"grinning",
"griot",
"grip",
"gripe",
"gripes",
"griping",
"grippe",
"gripsack",
"gris",
"grisaille",
"griselinia",
"griseofulvin",
"grison",
"grissino",
"grist",
"gristle",
"gristmill",
"grit",
"gritrock",
"grits",
"gritstone",
"grivet",
"grizzle",
"grizzly",
"groan",
"groaner",
"groat",
"groats",
"grocer",
"grocery",
"groenendael",
"groenlandia",
"grog",
"grogginess",
"grogram",
"groin",
"grommet",
"gromwell",
"gromyko",
"gronland",
"groom",
"grooming",
"groomsman",
"groove",
"groover",
"grooving",
"grope",
"gropius",
"grosbeak",
"groschen",
"grosgrain",
"gross",
"grossbeak",
"grossness",
"grossulariaceae",
"grosz",
"grot",
"grotesque",
"grotesqueness",
"grotesquerie",
"grotesquery",
"grotius",
"grotto",
"grouch",
"groucho",
"ground",
"groundball",
"groundberry",
"groundbreaker",
"groundbreaking",
"groundcover",
"grounder",
"groundfish",
"groundhog",
"grounding",
"groundkeeper",
"groundlessness",
"groundling",
"groundmass",
"groundnut",
"grounds",
"groundsel",
"groundsheet",
"groundskeeper",
"groundsman",
"groundspeed",
"groundwork",
"group",
"grouper",
"groupie",
"grouping",
"groupthink",
"groupware",
"grouse",
"grouseberry",
"grout",
"grove",
"groveler",
"groveller",
"groves",
"grower",
"growing",
"growl",
"growler",
"growling",
"grownup",
"growth",
"groyne",
"grozny",
"groznyy",
"grub",
"grubbiness",
"grubby",
"grubstake",
"grudge",
"gruel",
"gruesomeness",
"gruffness",
"grugru",
"gruidae",
"gruiformes",
"grumble",
"grumbler",
"grumbling",
"grume",
"grummet",
"grump",
"grumpiness",
"grundyism",
"grunge",
"grunt",
"grunter",
"grus",
"gruyere",
"gryllidae",
"gryphon",
"gspc",
"guacamole",
"guacharo",
"guadalajara",
"guadalcanal",
"guadeloupe",
"guaiac",
"guaiacum",
"guaira",
"guallatiri",
"guam",
"guama",
"guan",
"guanabana",
"guanabenz",
"guanaco",
"guangdong",
"guangzhou",
"guanine",
"guano",
"guanosine",
"guantanamo",
"guar",
"guarani",
"guarantee",
"guarantor",
"guaranty",
"guard",
"guardhouse",
"guardian",
"guardianship",
"guardrail",
"guardroom",
"guardsman",
"guarneri",
"guarnerius",
"guarnieri",
"guatemala",
"guatemalan",
"guava",
"guayaquil",
"guayule",
"gubbins",
"guck",
"gudgeon",
"guenevere",
"guenon",
"guerdon",
"guereza",
"gueridon",
"guerilla",
"guernsey",
"guerrilla",
"guess",
"guesser",
"guessing",
"guesstimate",
"guesswork",
"guest",
"guesthouse",
"guestimate",
"guestroom",
"guestworker",
"guevara",
"guevina",
"guff",
"guffaw",
"guggenheim",
"guiana",
"guib",
"guidance",
"guide",
"guidebook",
"guideline",
"guidepost",
"guideword",
"guild",
"guilder",
"guildhall",
"guile",
"guillemot",
"guilloche",
"guillotine",
"guilt",
"guiltiness",
"guiltlessness",
"guimpe",
"guinea",
"guinean",
"guinevere",
"guinness",
"guise",
"guitar",
"guitarfish",
"guitarist",
"gujarat",
"gujarati",
"gujerat",
"gujerati",
"gula",
"gulag",
"gulch",
"gulden",
"gulf",
"gulfweed",
"gull",
"gullet",
"gullibility",
"gulliver",
"gully",
"gulo",
"gulp",
"gulper",
"gulping",
"gulu",
"gulyas",
"gumbo",
"gumboil",
"gumdrop",
"gumma",
"gumminess",
"gumming",
"gummite",
"gummosis",
"gumption",
"gumshield",
"gumshoe",
"gumweed",
"gumwood",
"gunboat",
"guncotton",
"gunfight",
"gunfire",
"gunflint",
"gunite",
"gunk",
"gunlock",
"gunman",
"gunmetal",
"gunnel",
"gunner",
"gunnery",
"gunny",
"gunnysack",
"gunplay",
"gunpoint",
"gunpowder",
"gunrunner",
"gunrunning",
"gunshot",
"gunsight",
"gunslinger",
"gunsmith",
"gunstock",
"gunwale",
"guomindang",
"guppy",
"gurgle",
"gurkha",
"gurnard",
"gurney",
"guru",
"gush",
"gusher",
"gusset",
"gust",
"gustation",
"gustavus",
"gusto",
"gutenberg",
"guthrie",
"gutierrezia",
"gutlessness",
"guts",
"gutsiness",
"gutter",
"guttersnipe",
"guttiferae",
"guttiferales",
"guttural",
"guvnor",
"guyana",
"guyanese",
"guyot",
"guzzler",
"guzzling",
"gwydion",
"gwyn",
"gwynn",
"gymkhana",
"gymnadenia",
"gymnadeniopsis",
"gymnasium",
"gymnast",
"gymnastics",
"gymnelis",
"gymnocalycium",
"gymnocarpium",
"gymnocladus",
"gymnogyps",
"gymnomycota",
"gymnophiona",
"gymnopilus",
"gymnorhina",
"gymnosophist",
"gymnosophy",
"gymnosperm",
"gymnospermae",
"gymnosporangium",
"gymnura",
"gymslip",
"gynaecologist",
"gynaecology",
"gynaeolatry",
"gynandromorph",
"gynarchy",
"gynecocracy",
"gynecologist",
"gynecology",
"gynecomastia",
"gyneolatry",
"gynne",
"gynobase",
"gynoecium",
"gynogenesis",
"gynophobia",
"gynophore",
"gynostegium",
"gynura",
"gypaetus",
"gyps",
"gypsophila",
"gypsum",
"gypsy",
"gypsyweed",
"gypsywort",
"gyration",
"gyre",
"gyrfalcon",
"gyrinidae",
"gyro",
"gyrocompass",
"gyromitra",
"gyroplane",
"gyroscope",
"gyrostabiliser",
"gyrostabilizer",
"gyrus",
"gywn",
"haart",
"haastia",
"habacuc",
"habakkuk",
"habanera",
"habenaria",
"haber",
"haberdasher",
"haberdashery",
"habergeon",
"habiliment",
"habit",
"habitability",
"habitableness",
"habitant",
"habitat",
"habitation",
"habituation",
"habitude",
"habitue",
"habitus",
"habsburg",
"hacek",
"hachiman",
"hachure",
"hacienda",
"hack",
"hackamore",
"hackberry",
"hackbut",
"hackee",
"hackelia",
"hacker",
"hackle",
"hackles",
"hackmatack",
"hackney",
"hacksaw",
"hackwork",
"haddock",
"hadean",
"hades",
"hadith",
"hadj",
"hadji",
"hadrian",
"hadron",
"hadrosaur",
"hadrosauridae",
"hadrosaurus",
"haecceity",
"haeckel",
"haem",
"haemangioma",
"haemanthus",
"haematemesis",
"haematinic",
"haematite",
"haematobia",
"haematocele",
"haematochezia",
"haematocoele",
"haematocolpos",
"haematocrit",
"haematocyturia",
"haematogenesis",
"haematohiston",
"haematoidin",
"haematologist",
"haematology",
"haematolysis",
"haematoma",
"haematopodidae",
"haematopoiesis",
"haematopus",
"haematoxylon",
"haematoxylum",
"haematuria",
"haemitin",
"haemodialysis",
"haemodoraceae",
"haemodorum",
"haemogenesis",
"haemoglobin",
"haemoglobinemia",
"haemoglobinuria",
"haemolysin",
"haemolysis",
"haemophile",
"haemophilia",
"haemophiliac",
"haemopis",
"haemopoiesis",
"haemoproteid",
"haemoproteidae",
"haemoprotein",
"haemoproteus",
"haemoptysis",
"haemorrhage",
"haemorrhoid",
"haemosiderin",
"haemosiderosis",
"haemosporidia",
"haemosporidian",
"haemostasia",
"haemostasis",
"haemostat",
"haemothorax",
"haemulidae",
"haemulon",
"hafnium",
"haft",
"haftarah",
"haftorah",
"hagada",
"haganah",
"hagberry",
"hagbut",
"hagerstown",
"hagfish",
"haggada",
"haggadah",
"haggai",
"haggard",
"haggis",
"haggle",
"haggler",
"haggling",
"hagiographa",
"hagiographer",
"hagiographist",
"hagiography",
"hagiolatry",
"hagiologist",
"hagiology",
"hahn",
"hahnium",
"haick",
"haida",
"haifa",
"haik",
"haiku",
"hail",
"hailstone",
"hailstorm",
"haiphong",
"hair",
"hairball",
"hairbrush",
"haircare",
"haircloth",
"haircut",
"hairdo",
"hairdresser",
"hairdressing",
"hairgrip",
"hairiness",
"hairlessness",
"hairline",
"hairnet",
"hairpiece",
"hairpin",
"hairsbreadth",
"hairsplitter",
"hairsplitting",
"hairspring",
"hairstreak",
"hairstyle",
"hairstylist",
"hairtail",
"hairweaving",
"haiti",
"haitian",
"haji",
"hajj",
"hajji",
"hake",
"hakea",
"hakeem",
"hakenkreuz",
"hakham",
"hakim",
"hakka",
"halab",
"halacha",
"halaka",
"halakah",
"halal",
"halberd",
"halberdier",
"halchidhoma",
"halcion",
"halcyon",
"haldane",
"haldea",
"haldol",
"hale",
"haleness",
"halenia",
"haler",
"halesia",
"halevy",
"haley",
"half",
"halfback",
"halfbeak",
"halfpenny",
"halfpennyworth",
"halftime",
"halftone",
"haliaeetus",
"halibut",
"halicarnassus",
"halicoeres",
"halictidae",
"halide",
"halifax",
"halimodendron",
"haliotidae",
"haliotis",
"halite",
"halitosis",
"halitus",
"hall",
"hallah",
"halle",
"hallel",
"hallelujah",
"halley",
"halliard",
"hallmark",
"halloo",
"halloween",
"hallowmas",
"hallowmass",
"hallstand",
"hallucination",
"hallucinogen",
"hallucinosis",
"hallux",
"hallway",
"halm",
"halma",
"halo",
"haloalkane",
"halobacter",
"halobacteria",
"halobacterium",
"halocarbon",
"halocarpus",
"haloform",
"halogen",
"halogeton",
"halon",
"haloperidol",
"halophil",
"halophile",
"halophyte",
"haloragaceae",
"haloragidaceae",
"halothane",
"hals",
"halt",
"halter",
"haltere",
"halyard",
"hamadryad",
"hamamelidaceae",
"hamamelidae",
"hamamelidanthum",
"hamamelidoxylon",
"hamamelis",
"hamamelites",
"haman",
"hamartia",
"hamartoma",
"hamas",
"hamate",
"hamburg",
"hamburger",
"hame",
"hamelia",
"hamelin",
"hameln",
"hamilton",
"haminoea",
"hamitic",
"hamlet",
"hammarskjold",
"hammer",
"hammerhead",
"hammering",
"hammerlock",
"hammerstein",
"hammertoe",
"hammett",
"hamming",
"hammock",
"hammurabi",
"hammurapi",
"hamper",
"hampshire",
"hampton",
"hamster",
"hamstring",
"hamsun",
"hancock",
"hand",
"handbag",
"handball",
"handbarrow",
"handbasin",
"handbasket",
"handbell",
"handbill",
"handbook",
"handbow",
"handbreadth",
"handcar",
"handcart",
"handclap",
"handclasp",
"handcraft",
"handcuff",
"handedness",
"handel",
"handful",
"handgrip",
"handgun",
"handhold",
"handicap",
"handicapped",
"handicapper",
"handicraft",
"handiness",
"handiwork",
"handkerchief",
"handle",
"handlebar",
"handler",
"handline",
"handling",
"handlock",
"handloom",
"handmaid",
"handmaiden",
"handoff",
"handout",
"handover",
"handrail",
"handrest",
"hands",
"handsaw",
"handsbreadth",
"handset",
"handshake",
"handshaking",
"handsomeness",
"handspike",
"handspring",
"handstamp",
"handstand",
"handwear",
"handwheel",
"handwork",
"handwriting",
"handy",
"handyman",
"hang",
"hangar",
"hangbird",
"hangchow",
"hanger",
"hanging",
"hangman",
"hangnail",
"hangout",
"hangover",
"hangzhou",
"hani",
"hank",
"hankering",
"hankey",
"hankie",
"hanks",
"hanky",
"hannibal",
"hannover",
"hannukah",
"hanoi",
"hanover",
"hanoverian",
"hansard",
"hansom",
"hanukah",
"hanukkah",
"hanuman",
"haoma",
"haphazardness",
"haphtarah",
"haphtorah",
"haploid",
"haploidy",
"haplopappus",
"haplosporidia",
"haplosporidian",
"haplotype",
"happening",
"happenstance",
"happiness",
"hapsburg",
"haptoglobin",
"harakiri",
"harangue",
"haranguer",
"harare",
"harasser",
"harassment",
"harbinger",
"harbor",
"harborage",
"harbour",
"harbourage",
"hardback",
"hardbake",
"hardball",
"hardboard",
"hardcover",
"hardenbergia",
"hardening",
"hardheads",
"hardheartedness",
"hardihood",
"hardiness",
"harding",
"hardinggrass",
"hardliner",
"hardness",
"hardpan",
"hardship",
"hardtack",
"hardtop",
"hardware",
"hardwareman",
"hardwood",
"hardy",
"hare",
"harebell",
"haredi",
"hareem",
"harefoot",
"harelip",
"harem",
"hargeisa",
"hargreaves",
"haricot",
"harijan",
"harikari",
"harlem",
"harlequin",
"harlequinade",
"harlot",
"harlotry",
"harlow",
"harm",
"harmattan",
"harmfulness",
"harmonic",
"harmonica",
"harmonics",
"harmoniousness",
"harmonisation",
"harmoniser",
"harmonium",
"harmonization",
"harmonizer",
"harmony",
"harmsworth",
"harness",
"harp",
"harper",
"harpia",
"harpist",
"harpo",
"harpoon",
"harpooneer",
"harpooner",
"harpsichord",
"harpsichordist",
"harpulla",
"harpullia",
"harpy",
"harquebus",
"harridan",
"harrier",
"harriman",
"harris",
"harrisburg",
"harrisia",
"harrison",
"harrod",
"harrow",
"harshness",
"hart",
"harte",
"hartebeest",
"hartford",
"hartley",
"harvard",
"harvest",
"harvester",
"harvestfish",
"harvesting",
"harvestman",
"harvey",
"haschisch",
"hasdrubal",
"hasek",
"hash",
"hasheesh",
"hashish",
"hashmark",
"hasid",
"hasidim",
"hasidism",
"haslet",
"hasp",
"hassam",
"hassel",
"hassid",
"hassidim",
"hassidism",
"hassium",
"hassle",
"hassock",
"haste",
"hastinapura",
"hastiness",
"hastings",
"hatband",
"hatbox",
"hatch",
"hatchback",
"hatchel",
"hatchery",
"hatchet",
"hatching",
"hatchling",
"hatchway",
"hate",
"hatefulness",
"hatemonger",
"hater",
"hatful",
"hathaway",
"hatiora",
"hatmaker",
"hatpin",
"hatrack",
"hatred",
"hatter",
"hattiesburg",
"hauberk",
"haughtiness",
"haul",
"haulage",
"hauler",
"haulier",
"hauling",
"haulm",
"haunch",
"haunt",
"hausa",
"hausen",
"hausmannite",
"haussa",
"haustorium",
"hautbois",
"hautboy",
"hauteur",
"havana",
"havasupai",
"have",
"havel",
"havelock",
"haven",
"haversack",
"havoc",
"hawaii",
"hawaiian",
"hawala",
"hawfinch",
"hawk",
"hawkbill",
"hawkbit",
"hawker",
"hawking",
"hawkins",
"hawkishness",
"hawkmoth",
"hawksbill",
"hawkshaw",
"hawkweed",
"hawkyns",
"haworth",
"hawse",
"hawsehole",
"hawsepipe",
"hawser",
"hawthorn",
"hawthorne",
"hayastan",
"haycock",
"haydn",
"hayek",
"hayes",
"hayfield",
"hayfork",
"haying",
"hayloft",
"haymaker",
"haymaking",
"haymow",
"hayrack",
"hayrick",
"hayrig",
"hays",
"hayseed",
"haystack",
"hayti",
"haywire",
"haywood",
"hazan",
"hazard",
"hazardia",
"hazardousness",
"haze",
"hazel",
"hazelnut",
"hazelwood",
"haziness",
"hazlitt",
"hazmat",
"hcfc",
"hdtv",
"head",
"headache",
"headband",
"headboard",
"headcheese",
"headcount",
"headcounter",
"headdress",
"header",
"headfast",
"headfish",
"headful",
"headgear",
"headhunter",
"heading",
"headlamp",
"headland",
"headlight",
"headline",
"headliner",
"headlinese",
"headlock",
"headman",
"headmaster",
"headmastership",
"headmistress",
"headphone",
"headpiece",
"headpin",
"headquarters",
"headrace",
"headrest",
"headroom",
"headsail",
"headscarf",
"headset",
"headshake",
"headshaking",
"headship",
"headshot",
"headsman",
"headspace",
"headspring",
"headstall",
"headstand",
"headstock",
"headstone",
"headstream",
"headwaiter",
"headwater",
"headway",
"headwind",
"headword",
"healer",
"healing",
"health",
"healthcare",
"healthfulness",
"healthiness",
"heap",
"heaps",
"hearer",
"hearing",
"hearsay",
"hearse",
"hearst",
"heart",
"heartache",
"heartbeat",
"heartbreak",
"heartbreaker",
"heartburn",
"heartburning",
"hearth",
"hearthrug",
"hearthstone",
"heartiness",
"heartland",
"heartleaf",
"heartlessness",
"heartrot",
"hearts",
"heartsease",
"heartseed",
"heartsickness",
"heartstrings",
"heartthrob",
"heartwood",
"heat",
"heater",
"heath",
"heathen",
"heathenism",
"heather",
"heathfowl",
"heathland",
"heating",
"heatstroke",
"heaume",
"heave",
"heaven",
"heavens",
"heaver",
"heaves",
"heaviness",
"heaving",
"heaviside",
"heavy",
"heavyweight",
"hebbel",
"hebdomad",
"hebe",
"hebei",
"hebephrenia",
"hebetude",
"hebraism",
"hebraist",
"hebrew",
"hebrews",
"hebrides",
"hecate",
"hecatomb",
"hecht",
"heckelphone",
"heckle",
"heckler",
"heckling",
"hectare",
"hectogram",
"hectograph",
"hectoliter",
"hectolitre",
"hectometer",
"hectometre",
"hector",
"hedeoma",
"hedera",
"hedge",
"hedgefund",
"hedgehog",
"hedger",
"hedgerow",
"hedging",
"hediondilla",
"hedjaz",
"hedonism",
"hedonist",
"hedysarum",
"heed",
"heedfulness",
"heedlessness",
"heel",
"heelbone",
"hefa",
"heft",
"heftiness",
"hegari",
"hegel",
"hegelian",
"hegemon",
"hegemony",
"hegira",
"heidegger",
"heifer",
"height",
"heights",
"heilong",
"heimdal",
"heimdall",
"heimdallr",
"heinlein",
"heinousness",
"heinz",
"heir",
"heiress",
"heirloom",
"heisenberg",
"heist",
"hejaz",
"hejira",
"hela",
"helen",
"helena",
"helenium",
"heleodytes",
"heliamphora",
"helianthemum",
"helianthus",
"helichrysum",
"helicidae",
"helicon",
"helicopter",
"helicteres",
"heliobacter",
"heliogram",
"heliograph",
"heliogravure",
"heliolatry",
"heliometer",
"heliopause",
"heliophila",
"heliopsis",
"helios",
"heliosphere",
"heliotherapy",
"heliothis",
"heliotrope",
"heliotropism",
"heliotype",
"heliozoa",
"heliozoan",
"heliport",
"helipterum",
"helium",
"helix",
"hell",
"hellbender",
"hellcat",
"hellebore",
"helleborine",
"helleborus",
"hellene",
"hellenic",
"hellenism",
"heller",
"helleri",
"hellespont",
"hellfire",
"hellgrammiate",
"hellhole",
"hellhound",
"hellion",
"hellman",
"hello",
"helm",
"helmet",
"helmetflower",
"helmholtz",
"helminth",
"helminthiasis",
"helminthic",
"helmsman",
"heloderma",
"helodermatidae",
"heloise",
"helot",
"helotiaceae",
"helotiales",
"helotium",
"help",
"helpdesk",
"helper",
"helpfulness",
"helping",
"helplessness",
"helpmate",
"helpmeet",
"helsingfors",
"helsinki",
"helve",
"helvella",
"helvellaceae",
"helvetia",
"helvetian",
"helvetica",
"helwingia",
"helxine",
"hemachatus",
"hemangioma",
"hematemesis",
"hematin",
"hematinic",
"hematite",
"hematocele",
"hematochezia",
"hematochrome",
"hematocoele",
"hematocolpos",
"hematocrit",
"hematocyst",
"hematocytopenia",
"hematocyturia",
"hematogenesis",
"hematohiston",
"hematoidin",
"hematologist",
"hematology",
"hematolysis",
"hematoma",
"hematopoiesis",
"hematuria",
"heme",
"hemeralopia",
"hemerobiid",
"hemerobiidae",
"hemerocallis",
"hemiacetal",
"hemianopia",
"hemianopsia",
"hemiascomycetes",
"hemicrania",
"hemicycle",
"hemiepiphyte",
"hemigalus",
"hemigrammus",
"hemimetabola",
"hemimetabolism",
"hemimetaboly",
"hemimorphite",
"hemin",
"heming",
"hemingway",
"hemiparasite",
"hemiplegia",
"hemiplegic",
"hemipode",
"hemiprocnidae",
"hemiptera",
"hemipteran",
"hemipteron",
"hemipteronatus",
"hemiramphidae",
"hemisphere",
"hemitripterus",
"hemline",
"hemlock",
"hemminge",
"hemochromatosis",
"hemodialysis",
"hemodialyzer",
"hemodynamics",
"hemofil",
"hemogenesis",
"hemoglobin",
"hemoglobinemia",
"hemoglobinuria",
"hemolysin",
"hemolysis",
"hemophile",
"hemophilia",
"hemophiliac",
"hemopoiesis",
"hemoprotein",
"hemoptysis",
"hemorrhage",
"hemorrhoid",
"hemosiderin",
"hemosiderosis",
"hemostasia",
"hemostasis",
"hemostat",
"hemothorax",
"hemp",
"hemstitch",
"hemstitching",
"henbane",
"henbit",
"henchman",
"hencoop",
"hendiadys",
"hendrix",
"henhouse",
"henna",
"henroost",
"henry",
"henson",
"hepadnavirus",
"heparin",
"hepatic",
"hepatica",
"hepaticae",
"hepaticopsida",
"hepatitis",
"hepatocarcinoma",
"hepatoflavin",
"hepatoma",
"hepatomegaly",
"hepatotoxin",
"hepburn",
"hephaestus",
"hephaistos",
"heptad",
"heptagon",
"heptane",
"hepworth",
"hera",
"heracles",
"heracleum",
"heraclitus",
"herakles",
"herald",
"heraldry",
"herat",
"herb",
"herbage",
"herbal",
"herbalist",
"herbarium",
"herbart",
"herbert",
"herbicide",
"herbivore",
"herculaneum",
"hercules",
"herculius",
"herd",
"herder",
"herdsman",
"here",
"hereafter",
"hereditament",
"hereditarianism",
"heredity",
"hereford",
"hereness",
"herero",
"heresy",
"heretic",
"heritage",
"heritiera",
"heritor",
"herm",
"herman",
"hermann",
"hermannia",
"hermaphrodism",
"hermaphrodite",
"hermaphroditism",
"hermaphroditus",
"hermeneutics",
"hermes",
"hermissenda",
"hermit",
"hermitage",
"hermosillo",
"hernaria",
"hernia",
"herniation",
"hero",
"herod",
"herodotus",
"heroic",
"heroics",
"heroin",
"heroine",
"heroism",
"heron",
"heronry",
"herpangia",
"herpes",
"herpestes",
"herpetologist",
"herpetology",
"herr",
"herrenvolk",
"herrerasaur",
"herrerasaurus",
"herrick",
"herring",
"herringbone",
"herschel",
"hershey",
"hertfordshire",
"hertha",
"hertz",
"herzberg",
"heshvan",
"hesiod",
"hesitance",
"hesitancy",
"hesitater",
"hesitation",
"hesitator",
"hesperides",
"hesperiphona",
"hesperis",
"hesperus",
"hess",
"hesse",
"hessian",
"hessonite",
"hestia",
"heteranthera",
"heterocephalus",
"heterocycle",
"heterocyclic",
"heterodon",
"heterodoxy",
"heterogeneity",
"heterogenesis",
"heterograft",
"heterokontae",
"heterology",
"heteromeles",
"heterometaboly",
"heteromyidae",
"heteronym",
"heteroploid",
"heteroploidy",
"heteroptera",
"heteroscelus",
"heterosexism",
"heterosexual",
"heterosexualism",
"heterosexuality",
"heterosis",
"heterosomata",
"heterospory",
"heterostracan",
"heterostraci",
"heterotaxy",
"heterotheca",
"heterotrichales",
"heterotroph",
"heterozygosity",
"heterozygote",
"heth",
"heuchera",
"heulandite",
"heuristic",
"hevea",
"hevesy",
"hewer",
"hexachlorophene",
"hexad",
"hexadrol",
"hexagon",
"hexagram",
"hexagrammidae",
"hexagrammos",
"hexahedron",
"hexalectris",
"hexameter",
"hexamita",
"hexanchidae",
"hexanchus",
"hexane",
"hexapod",
"hexapoda",
"hexenbesen",
"hexestrol",
"hexose",
"heyday",
"heyerdahl",
"heyrovsky",
"heyse",
"heyward",
"hezbollah",
"hezekiah",
"hiatus",
"hiawatha",
"hibachi",
"hibbertia",
"hibbing",
"hibernation",
"hibernia",
"hibiscus",
"hiccough",
"hiccup",
"hick",
"hickey",
"hickock",
"hickory",
"hidatsa",
"hiddenite",
"hiddenness",
"hide",
"hideaway",
"hideousness",
"hideout",
"hiding",
"hidrosis",
"hieracium",
"hierarch",
"hierarchy",
"hieratic",
"hierocracy",
"hieroglyph",
"hieroglyphic",
"hierolatry",
"hieronymus",
"higginson",
"high",
"highball",
"highbinder",
"highboard",
"highboy",
"highbrow",
"highchair",
"highflier",
"highflyer",
"highjack",
"highjacker",
"highjacking",
"highland",
"highlander",
"highlands",
"highlife",
"highlight",
"highlighter",
"highlighting",
"highness",
"highroad",
"highschool",
"highwater",
"highway",
"highwayman",
"higi",
"hijab",
"hijack",
"hijacker",
"hijacking",
"hijaz",
"hijinks",
"hike",
"hiker",
"hiking",
"hilarity",
"hilbert",
"hildebrand",
"hill",
"hillary",
"hillbilly",
"hillel",
"hilliness",
"hillock",
"hillside",
"hilltop",
"hilo",
"hilt",
"hilum",
"hilus",
"himalaya",
"himalayas",
"himalayish",
"himantoglossum",
"himantopus",
"himmler",
"hinault",
"hinayana",
"hinayanism",
"hinayanist",
"hind",
"hindbrain",
"hindemith",
"hindenburg",
"hinderance",
"hindfoot",
"hindgut",
"hindi",
"hindlimb",
"hindoo",
"hindooism",
"hindoostani",
"hindostani",
"hindquarter",
"hindquarters",
"hindrance",
"hindshank",
"hindsight",
"hindu",
"hinduism",
"hindustan",
"hindustani",
"hinge",
"hinny",
"hint",
"hinterland",
"hipbone",
"hipflask",
"hipline",
"hipparchus",
"hippeastrum",
"hippie",
"hippies",
"hippo",
"hippobosca",
"hippoboscid",
"hippoboscidae",
"hippocampus",
"hippocrates",
"hippocrepis",
"hippodamia",
"hippodrome",
"hippoglossoides",
"hippoglossus",
"hippopotamidae",
"hippopotamus",
"hipposideridae",
"hipposideros",
"hippotragus",
"hippy",
"hipster",
"hipsters",
"hipsurus",
"hire",
"hireling",
"hirer",
"hirohito",
"hiroshima",
"hirschfeld",
"hirschsprung",
"hirsuteness",
"hirsutism",
"hirudinea",
"hirudinean",
"hirudinidae",
"hirudo",
"hirundinidae",
"hirundo",
"hispanic",
"hispaniola",
"hiss",
"hisser",
"hissing",
"histaminase",
"histamine",
"histidine",
"histiocyte",
"histiocytosis",
"histogram",
"histologist",
"histology",
"histone",
"historian",
"historicalness",
"historicism",
"historiographer",
"historiography",
"history",
"histrion",
"histrionics",
"hitch",
"hitchcock",
"hitchhiker",
"hitchings",
"hitchiti",
"hitchrack",
"hitler",
"hitman",
"hitter",
"hitting",
"hittite",
"hive",
"hives",
"hizballah",
"hizbollah",
"hizbullah",
"hmong",
"hoactzin",
"hoagie",
"hoagland",
"hoagy",
"hoar",
"hoard",
"hoarder",
"hoarding",
"hoarfrost",
"hoariness",
"hoarseness",
"hoatzin",
"hoax",
"hoaxer",
"hobart",
"hobbes",
"hobbit",
"hobble",
"hobbledehoy",
"hobbler",
"hobbs",
"hobby",
"hobbyhorse",
"hobbyism",
"hobbyist",
"hobgoblin",
"hobnail",
"hobo",
"hock",
"hockey",
"hodeida",
"hoder",
"hodgepodge",
"hodgkin",
"hodman",
"hodometer",
"hodoscope",
"hodr",
"hodur",
"hoecake",
"hoenir",
"hoffa",
"hoffman",
"hoffmann",
"hoffmannsthal",
"hogan",
"hogarth",
"hogback",
"hogchoker",
"hogfish",
"hogg",
"hogget",
"hoggishness",
"hogmanay",
"hogshead",
"hogwash",
"hogweed",
"hohenlinden",
"hohenzollern",
"hoheria",
"hohhot",
"hoist",
"hoister",
"hoka",
"hokan",
"hokkaido",
"hokkianese",
"hokum",
"hokusai",
"holarrhena",
"holbein",
"holbrookia",
"holcus",
"hold",
"holdall",
"holder",
"holdfast",
"holding",
"holdout",
"holdover",
"holdup",
"hole",
"holibut",
"holiday",
"holidaymaker",
"holiness",
"holism",
"holla",
"holland",
"hollandaise",
"hollander",
"hollands",
"holler",
"hollering",
"hollerith",
"hollo",
"holloa",
"hollow",
"holloware",
"hollowness",
"hollowware",
"holly",
"hollygrape",
"hollyhock",
"hollywood",
"holmes",
"holmium",
"holocaust",
"holocene",
"holocentridae",
"holocentrus",
"holocephalan",
"holocephali",
"holocephalian",
"holofernes",
"hologram",
"holograph",
"holography",
"holometabola",
"holometabolism",
"holometaboly",
"holonym",
"holonymy",
"holophyte",
"holothuria",
"holothurian",
"holothuridae",
"holothuroidea",
"holotype",
"holstein",
"holster",
"holy",
"holystone",
"homage",
"homaridae",
"homarus",
"hombre",
"homburg",
"home",
"homebody",
"homebound",
"homeboy",
"homebrew",
"homebuilder",
"homecoming",
"homefolk",
"homegirl",
"homel",
"homeland",
"homeless",
"homelessness",
"homeliness",
"homemaker",
"homemaking",
"homeobox",
"homeopath",
"homeopathy",
"homeostasis",
"homeotherm",
"homeowner",
"homepage",
"homer",
"homeroom",
"homesickness",
"homespun",
"homestead",
"homesteader",
"homestretch",
"hometown",
"homework",
"homicide",
"homiletics",
"homily",
"hominid",
"hominidae",
"hominoid",
"hominoidea",
"hominy",
"hommos",
"homo",
"homoeopath",
"homoeopathy",
"homoeroticism",
"homogenate",
"homogeneity",
"homogeneousness",
"homogenisation",
"homogenization",
"homogeny",
"homograft",
"homograph",
"homogyne",
"homoiotherm",
"homology",
"homomorphism",
"homomorphy",
"homona",
"homonym",
"homonymy",
"homophile",
"homophobe",
"homophobia",
"homophone",
"homophony",
"homoptera",
"homopteran",
"homosexual",
"homosexualism",
"homosexuality",
"homospory",
"homotherm",
"homozygosity",
"homozygote",
"homunculus",
"homyel",
"honcho",
"hondo",
"honduran",
"honduras",
"hone",
"honegger",
"honestness",
"honesty",
"honey",
"honeybee",
"honeybells",
"honeycomb",
"honeycreeper",
"honeydew",
"honeyflower",
"honeymoon",
"honeymooner",
"honeypot",
"honeysucker",
"honeysuckle",
"honiara",
"honk",
"honker",
"honkey",
"honkie",
"honky",
"honkytonk",
"honolulu",
"honor",
"honorableness",
"honorarium",
"honoree",
"honorific",
"honoring",
"honour",
"honourableness",
"honours",
"honshu",
"hooch",
"hood",
"hoodlum",
"hoodmold",
"hoodmould",
"hoodoo",
"hoodooism",
"hooey",
"hoof",
"hoofer",
"hoofing",
"hoofprint",
"hook",
"hookah",
"hooke",
"hooker",
"hooking",
"hooknose",
"hooks",
"hookup",
"hookworm",
"hooky",
"hooligan",
"hooliganism",
"hoop",
"hoopla",
"hoopoe",
"hoopoo",
"hoops",
"hoopskirt",
"hooray",
"hoosegow",
"hoosgow",
"hoosier",
"hoot",
"hootch",
"hooter",
"hoover",
"hope",
"hopeful",
"hopefulness",
"hopeh",
"hopei",
"hopelessness",
"hoper",
"hopi",
"hopkins",
"hopkinson",
"hopper",
"hops",
"hopsack",
"hopsacking",
"hopscotch",
"horace",
"horde",
"hordeolum",
"hordeum",
"horehound",
"horizon",
"horizontal",
"horizontality",
"hormone",
"horn",
"hornbeam",
"hornbill",
"hornblende",
"hornbook",
"horne",
"horneophyton",
"hornet",
"horney",
"hornfels",
"horniness",
"hornist",
"hornpipe",
"hornpout",
"hornstone",
"hornwort",
"horologe",
"horologer",
"horologist",
"horology",
"horoscope",
"horoscopy",
"horowitz",
"horridness",
"horripilation",
"horror",
"horse",
"horseback",
"horsebean",
"horsebox",
"horsecar",
"horsecloth",
"horsefish",
"horseflesh",
"horsefly",
"horsehair",
"horsehead",
"horsehide",
"horselaugh",
"horseleech",
"horseman",
"horsemanship",
"horsemeat",
"horsemint",
"horseplay",
"horsepond",
"horsepower",
"horseradish",
"horseshit",
"horseshoe",
"horseshoer",
"horseshoes",
"horseshow",
"horsetail",
"horseweed",
"horsewhip",
"horsewhipping",
"horsewoman",
"horst",
"horta",
"hortensia",
"horticulture",
"horticulturist",
"horus",
"hosanna",
"hose",
"hosea",
"hosepipe",
"hosier",
"hosiery",
"hospice",
"hospitableness",
"hospital",
"hospitalisation",
"hospitality",
"hospitalization",
"host",
"hosta",
"hostaceae",
"hostage",
"hostel",
"hosteller",
"hostelry",
"hostess",
"hostile",
"hostilities",
"hostility",
"hostler",
"hotbed",
"hotbox",
"hotcake",
"hotchpotch",
"hotdog",
"hotei",
"hotel",
"hotelier",
"hotelkeeper",
"hotelman",
"hotfoot",
"hoth",
"hothead",
"hothouse",
"hothr",
"hotness",
"hotplate",
"hotpot",
"hotshot",
"hotspot",
"hotspur",
"hottentot",
"hottonia",
"houdah",
"houdini",
"houghton",
"houhere",
"hoummos",
"hound",
"hour",
"hourglass",
"houri",
"hours",
"housatonic",
"house",
"houseboat",
"housebreaker",
"housebreaking",
"housebuilder",
"housecleaning",
"housecoat",
"housecraft",
"housedog",
"housefather",
"housefly",
"houseful",
"houseguest",
"household",
"householder",
"househusband",
"housekeeper",
"housekeeping",
"houselights",
"housemaid",
"houseman",
"housemaster",
"housemate",
"housemother",
"housepaint",
"houseplant",
"houseroom",
"housetop",
"housewarming",
"housewife",
"housewifery",
"housework",
"housewrecker",
"housing",
"housman",
"houston",
"houttuynia",
"houyhnhnm",
"houyhnhnms",
"hovea",
"hovel",
"hovercraft",
"howard",
"howdah",
"howdy",
"howe",
"howells",
"howitzer",
"howl",
"howler",
"howling",
"hoya",
"hoyden",
"hoydenism",
"hoyle",
"hrolf",
"hrvatska",
"hryvnia",
"hsian",
"html",
"http",
"huainaputina",
"hualapai",
"hualpai",
"huamachil",
"huambo",
"huarache",
"huaraches",
"huascaran",
"hubbard",
"hubble",
"hubbub",
"hubby",
"hubcap",
"hubel",
"hubris",
"huck",
"huckaback",
"huckleberry",
"huckster",
"huddle",
"huddler",
"hudood",
"hudson",
"hudsonia",
"hudud",
"huff",
"huffiness",
"huffing",
"huffishness",
"hugger",
"hugging",
"huggins",
"hughes",
"hugo",
"hugueninia",
"huguenot",
"huisache",
"huitre",
"huji",
"hula",
"hulk",
"hull",
"hullabaloo",
"hullo",
"hulsea",
"human",
"humaneness",
"humanisation",
"humanism",
"humanist",
"humanitarian",
"humanitarianism",
"humanities",
"humanity",
"humanization",
"humankind",
"humanness",
"humanoid",
"humans",
"humate",
"humber",
"humblebee",
"humbleness",
"humboldt",
"humbug",
"humdinger",
"humdrum",
"hume",
"humectant",
"humerus",
"humidifier",
"humidity",
"humidness",
"humification",
"humiliation",
"humility",
"humin",
"hummer",
"humming",
"hummingbird",
"hummock",
"hummus",
"humor",
"humoring",
"humorist",
"humorousness",
"humour",
"humourist",
"humous",
"hump",
"humpback",
"humperdinck",
"humulin",
"humulus",
"humus",
"humvee",
"hunan",
"hunch",
"hunchback",
"hundred",
"hundredth",
"hundredweight",
"hungarian",
"hungary",
"hunger",
"hungriness",
"hunk",
"hunkpapa",
"hunnemannia",
"hunt",
"hunter",
"hunting",
"huntington",
"huntress",
"huntsman",
"huntsville",
"hupa",
"hurdle",
"hurdler",
"hurdles",
"hurdling",
"hurl",
"hurler",
"hurling",
"hurok",
"huron",
"hurrah",
"hurricane",
"hurriedness",
"hurry",
"hurrying",
"hurt",
"hurting",
"husain",
"husayn",
"husband",
"husbandman",
"husbandry",
"hush",
"hushing",
"hushpuppy",
"husk",
"huskiness",
"husking",
"husky",
"huss",
"hussar",
"hussein",
"husserl",
"hussite",
"hussy",
"hustings",
"hustle",
"hustler",
"huston",
"hutch",
"hutchins",
"hutchinson",
"hutment",
"hutton",
"hutu",
"hutzpah",
"huxley",
"huygens",
"hyacinth",
"hyacinthaceae",
"hyacinthoides",
"hyades",
"hyaena",
"hyaenidae",
"hyalin",
"hyaline",
"hyalinisation",
"hyalinization",
"hyaloid",
"hyalophora",
"hyaloplasm",
"hyalosperma",
"hyalospongiae",
"hyaluronidase",
"hyazyme",
"hybanthus",
"hybrid",
"hybridisation",
"hybridization",
"hybridizing",
"hybridoma",
"hydantoin",
"hydathode",
"hydatid",
"hydatidosis",
"hyderabad",
"hydnaceae",
"hydnocarpus",
"hydnoraceae",
"hydnum",
"hydra",
"hydralazine",
"hydramnios",
"hydrangea",
"hydrangeaceae",
"hydrant",
"hydrargyrum",
"hydrarthrosis",
"hydrastis",
"hydrate",
"hydration",
"hydraulics",
"hydrazine",
"hydrazoite",
"hydremia",
"hydride",
"hydrilla",
"hydrobates",
"hydrobatidae",
"hydrocarbon",
"hydrocele",
"hydrocephalus",
"hydrocephaly",
"hydrocharis",
"hydrochloride",
"hydrochoeridae",
"hydrochoerus",
"hydrocolloid",
"hydrocortisone",
"hydrocortone",
"hydrocracking",
"hydrodamalis",
"hydrodiuril",
"hydrodynamics",
"hydrofoil",
"hydrogel",
"hydrogen",
"hydrogenation",
"hydrography",
"hydroid",
"hydrokinetics",
"hydrolith",
"hydrologist",
"hydrology",
"hydrolysate",
"hydrolysis",
"hydromancer",
"hydromancy",
"hydromantes",
"hydromel",
"hydrometer",
"hydrometry",
"hydromorphone",
"hydromyinae",
"hydromys",
"hydronephrosis",
"hydropathy",
"hydrophidae",
"hydrophobia",
"hydrophobicity",
"hydrophyllaceae",
"hydrophyllum",
"hydrophyte",
"hydroplane",
"hydroponics",
"hydrops",
"hydrosphere",
"hydrostatics",
"hydrotherapy",
"hydrothorax",
"hydroxide",
"hydroxybenzene",
"hydroxyl",
"hydroxymethyl",
"hydroxyproline",
"hydroxyzine",
"hydrozoa",
"hydrozoan",
"hydrus",
"hyemoschus",
"hyena",
"hygeia",
"hygiene",
"hygienics",
"hygienist",
"hygrocybe",
"hygrodeik",
"hygrometer",
"hygrophoraceae",
"hygrophorus",
"hygrophyte",
"hygroscope",
"hygroton",
"hygrotrama",
"hyla",
"hylactophryne",
"hylidae",
"hylobates",
"hylobatidae",
"hylocereus",
"hylocichla",
"hylophylax",
"hymen",
"hymenaea",
"hymenanthera",
"hymeneal",
"hymeneals",
"hymenium",
"hymenogastrales",
"hymenomycetes",
"hymenophyllum",
"hymenopter",
"hymenoptera",
"hymenopteran",
"hymenopteron",
"hymie",
"hymn",
"hymnal",
"hymnary",
"hymnbook",
"hymnody",
"hynerpeton",
"hyoid",
"hyoscine",
"hyoscyamine",
"hyoscyamus",
"hypallage",
"hypanthium",
"hypatia",
"hype",
"hypentelium",
"hyperacidity",
"hyperactivity",
"hyperacusia",
"hyperacusis",
"hyperadrenalism",
"hyperaemia",
"hyperbaton",
"hyperbola",
"hyperbole",
"hyperboloid",
"hyperborean",
"hypercalcaemia",
"hypercalcemia",
"hypercalcinuria",
"hypercalciuria",
"hypercapnia",
"hypercarbia",
"hypercatalectic",
"hypercoaster",
"hyperdactyly",
"hyperemesis",
"hyperemia",
"hyperextension",
"hyperglycaemia",
"hyperglycemia",
"hyperhidrosis",
"hypericaceae",
"hypericales",
"hypericism",
"hypericum",
"hyperidrosis",
"hyperion",
"hyperkalemia",
"hyperlink",
"hyperlipaemia",
"hyperlipemia",
"hyperlipidaemia",
"hyperlipidemia",
"hyperlipoidemia",
"hypermarket",
"hypermastigina",
"hypermastigote",
"hypermedia",
"hypermenorrhea",
"hypermetropia",
"hypermetropy",
"hypermotility",
"hypernatremia",
"hypernym",
"hypernymy",
"hyperoartia",
"hyperodontidae",
"hyperoglyphe",
"hyperon",
"hyperoodon",
"hyperope",
"hyperopia",
"hyperotreta",
"hyperpiesia",
"hyperpiesis",
"hyperplasia",
"hyperpnea",
"hyperpyrexia",
"hypersecretion",
"hypersomnia",
"hypersplenism",
"hyperstat",
"hypertensin",
"hypertension",
"hypertensive",
"hypertext",
"hyperthermia",
"hyperthermy",
"hyperthyroidism",
"hypertonia",
"hypertonicity",
"hypertonus",
"hypertrophy",
"hypervelocity",
"hypervolaemia",
"hypervolemia",
"hypesthesia",
"hypha",
"hyphantria",
"hyphema",
"hyphen",
"hyphenation",
"hypnagogue",
"hypnoanalysis",
"hypnogenesis",
"hypnopedia",
"hypnophobia",
"hypnos",
"hypnosis",
"hypnotherapy",
"hypnotic",
"hypnotiser",
"hypnotism",
"hypnotist",
"hypnotizer",
"hypo",
"hypoadrenalism",
"hypobasidium",
"hypoblast",
"hypocalcaemia",
"hypocalcemia",
"hypocapnia",
"hypocellularity",
"hypochaeris",
"hypochlorite",
"hypochoeris",
"hypochondria",
"hypochondriac",
"hypochondriasis",
"hypochondrium",
"hypocorism",
"hypocreaceae",
"hypocreales",
"hypocrisy",
"hypocrite",
"hypocycloid",
"hypoderma",
"hypodermatidae",
"hypodermic",
"hypodermis",
"hypoesthesia",
"hypoglossal",
"hypoglycaemia",
"hypoglycemia",
"hypogonadism",
"hypokalemia",
"hyponatremia",
"hyponym",
"hyponymy",
"hypopachus",
"hypophysectomy",
"hypophysis",
"hypopitys",
"hypoplasia",
"hypopnea",
"hypoproteinemia",
"hyposmia",
"hypospadias",
"hypostasis",
"hypostatisation",
"hypostatization",
"hypotension",
"hypotensive",
"hypotenuse",
"hypothalamus",
"hypothermia",
"hypothesis",
"hypothetical",
"hypothyroidism",
"hypotonia",
"hypotonicity",
"hypotonus",
"hypovitaminosis",
"hypovolaemia",
"hypovolemia",
"hypoxia",
"hypoxidaceae",
"hypoxis",
"hypozeugma",
"hypozeuxis",
"hypsiglena",
"hypsiprymnodon",
"hypsography",
"hypsometer",
"hypsometry",
"hyracoidea",
"hyracotherium",
"hyrax",
"hyson",
"hyssop",
"hyssopus",
"hysterectomy",
"hysteresis",
"hysteria",
"hysteric",
"hysterics",
"hysteroscopy",
"hysterotomy",
"hystricidae",
"hystricomorpha",
"hytrin",
"iaea",
"iago",
"iamb",
"iambic",
"iambus",
"ianfu",
"iapetus",
"ibadan",
"iberia",
"iberian",
"iberis",
"ibert",
"ibex",
"ibis",
"ibrahim",
"ibrd",
"ibsen",
"ibuprofen",
"icaco",
"icao",
"icarus",
"icbm",
"iceberg",
"iceboat",
"icebox",
"icebreaker",
"icecap",
"icecream",
"icefall",
"icehouse",
"iceland",
"icelander",
"icelandic",
"iceman",
"icepick",
"icetray",
"ichneumon",
"ichneumonidae",
"ichor",
"ichthyolatry",
"ichthyologist",
"ichthyology",
"ichthyosaur",
"ichthyosauria",
"ichthyosauridae",
"ichthyosaurus",
"ichthyosis",
"ichyostega",
"icicle",
"iciness",
"icing",
"icon",
"iconoclasm",
"iconoclast",
"iconography",
"iconolatry",
"iconology",
"iconoscope",
"icosahedron",
"icsh",
"ictalurus",
"icteria",
"icteridae",
"icterus",
"ictiobus",
"ictodosaur",
"ictodosauria",
"ictonyx",
"ictus",
"idaho",
"idahoan",
"iddm",
"idea",
"ideal",
"idealisation",
"idealism",
"idealist",
"ideality",
"idealization",
"idealogue",
"ideation",
"identicalness",
"identification",
"identifier",
"identikit",
"identity",
"ideogram",
"ideograph",
"ideography",
"ideologist",
"ideologue",
"ideology",
"ides",
"idesia",
"idiocy",
"idiolatry",
"idiolect",
"idiom",
"idiopathy",
"idiosyncrasy",
"idiot",
"iditarod",
"idle",
"idleness",
"idler",
"idling",
"idocrase",
"idol",
"idolater",
"idolatress",
"idolatry",
"idolisation",
"idoliser",
"idolization",
"idolizer",
"idun",
"idyl",
"idyll",
"igbo",
"igigi",
"iglesias",
"igloo",
"iglu",
"ignatius",
"igniter",
"ignition",
"ignitor",
"ignobility",
"ignobleness",
"ignominiousness",
"ignominy",
"ignoramus",
"ignorance",
"ignorantness",
"iguana",
"iguania",
"iguanid",
"iguanidae",
"iguanodon",
"iguanodontidae",
"iguassu",
"iguazu",
"ijssel",
"ijsselmeer",
"ijtihad",
"ikhanaton",
"ikon",
"ilama",
"ileitis",
"ileostomy",
"ileum",
"ileus",
"ilex",
"iliad",
"iliamna",
"ilion",
"ilium",
"illampu",
"illation",
"illecebrum",
"illegality",
"illegibility",
"illegitimacy",
"illegitimate",
"illiberality",
"illicitness",
"illicium",
"illimani",
"illinois",
"illinoisan",
"illiteracy",
"illiterate",
"illness",
"illogic",
"illogicality",
"illogicalness",
"illuminance",
"illuminant",
"illumination",
"illusion",
"illusionist",
"illustration",
"illustrator",
"illustriousness",
"illyria",
"illyrian",
"ilmen",
"ilmenite",
"ilosone",
"image",
"imagery",
"imaginary",
"imagination",
"imaginativeness",
"imaging",
"imagism",
"imago",
"imam",
"imaret",
"imaum",
"imavate",
"imbalance",
"imbauba",
"imbecile",
"imbecility",
"imbiber",
"imbibing",
"imbibition",
"imbrication",
"imbroglio",
"imidazole",
"imide",
"iminazole",
"imipramine",
"imitation",
"imitator",
"immaculateness",
"immanence",
"immanency",
"immateriality",
"immatureness",
"immaturity",
"immediacy",
"immediateness",
"immenseness",
"immensity",
"immersion",
"immigrant",
"immigration",
"imminence",
"imminency",
"imminentness",
"immobilisation",
"immobility",
"immobilization",
"immobilizing",
"immoderateness",
"immoderation",
"immodesty",
"immolation",
"immorality",
"immortal",
"immortality",
"immortelle",
"immotility",
"immovability",
"immovable",
"immovableness",
"immune",
"immunisation",
"immunity",
"immunization",
"immunoassay",
"immunochemistry",
"immunogen",
"immunogenicity",
"immunoglobulin",
"immunologist",
"immunology",
"immunopathology",
"immunotherapy",
"immurement",
"immutability",
"immutableness",
"impact",
"impaction",
"impairer",
"impairment",
"impala",
"impalement",
"impalpability",
"impartation",
"impartiality",
"imparting",
"impasse",
"impassiveness",
"impassivity",
"impasto",
"impatience",
"impeachability",
"impeachment",
"impeccability",
"impecuniousness",
"impedance",
"impediment",
"impedimenta",
"impeller",
"impendence",
"impendency",
"impenetrability",
"impenitence",
"impenitency",
"imperative",
"imperativeness",
"imperfect",
"imperfection",
"imperfective",
"imperfectness",
"imperial",
"imperialism",
"imperialist",
"imperiousness",
"imperishability",
"imperishingness",
"imperium",
"impermanence",
"impermanency",
"impermeability",
"impermeableness",
"impersonation",
"impersonator",
"impertinence",
"imperviousness",
"impetigo",
"impetuosity",
"impetuousness",
"impetus",
"impiety",
"impingement",
"impinging",
"impiousness",
"impishness",
"implant",
"implantation",
"implausibility",
"implausibleness",
"implement",
"implementation",
"implication",
"implicitness",
"implosion",
"impoliteness",
"imponderable",
"import",
"importance",
"importation",
"importee",
"importer",
"importing",
"importunity",
"imposition",
"impossibility",
"impossible",
"impossibleness",
"impost",
"imposter",
"impostor",
"imposture",
"impotence",
"impotency",
"impounding",
"impoundment",
"impoverishment",
"impracticality",
"imprecation",
"impreciseness",
"imprecision",
"impregnability",
"impregnation",
"impresario",
"impress",
"impression",
"impressionism",
"impressionist",
"impressiveness",
"impressment",
"imprimatur",
"imprint",
"imprinting",
"imprisonment",
"improbability",
"improbableness",
"impromptu",
"improperness",
"impropriety",
"improvement",
"improver",
"improvidence",
"improvisation",
"imprudence",
"impudence",
"impuissance",
"impulse",
"impulsion",
"impulsiveness",
"impunity",
"impureness",
"impurity",
"imputation",
"imuran",
"inability",
"inaccessibility",
"inaccuracy",
"inachis",
"inaction",
"inactivation",
"inactiveness",
"inactivity",
"inadequacy",
"inadequateness",
"inadmissibility",
"inadvertence",
"inadvertency",
"inadvisability",
"inamorata",
"inamorato",
"inanimateness",
"inanition",
"inanity",
"inanna",
"inapplicability",
"inappositeness",
"inaptitude",
"inaptness",
"inattention",
"inattentiveness",
"inaudibility",
"inaudibleness",
"inaugural",
"inauguration",
"inbreeding",
"inca",
"incalescence",
"incan",
"incandescence",
"incantation",
"incapability",
"incapableness",
"incapacity",
"incarceration",
"incarnation",
"incasement",
"incaution",
"incautiousness",
"incendiarism",
"incendiary",
"incense",
"incentive",
"inception",
"incertitude",
"incessancy",
"incessantness",
"incest",
"inch",
"incheon",
"inchoative",
"inchon",
"inchworm",
"incidence",
"incident",
"incidental",
"incienso",
"incineration",
"incinerator",
"incipience",
"incipiency",
"incision",
"incisiveness",
"incisor",
"incisura",
"incisure",
"incitation",
"incitement",
"inciter",
"incivility",
"inclemency",
"inclementness",
"inclination",
"incline",
"inclining",
"inclinometer",
"inclosure",
"inclusion",
"incognizance",
"incoherence",
"incoherency",
"income",
"incoming",
"incommutability",
"incompatibility",
"incompetence",
"incompetency",
"incompetent",
"incompleteness",
"incomprehension",
"inconel",
"incongruity",
"incongruousness",
"inconsequence",
"inconsideration",
"inconsistency",
"inconstancy",
"incontinence",
"incontinency",
"inconvenience",
"incoordination",
"incorporation",
"incorporeality",
"incorrectness",
"incorruption",
"incorruptness",
"increase",
"incredibility",
"incredibleness",
"incredulity",
"increment",
"incrimination",
"incrustation",
"incubation",
"incubator",
"incubus",
"inculcation",
"inculpability",
"inculpableness",
"inculpation",
"incumbency",
"incumbent",
"incumbrance",
"incurability",
"incurable",
"incurableness",
"incurrence",
"incurring",
"incursion",
"incurvation",
"incurvature",
"incus",
"indaba",
"indapamide",
"indebtedness",
"indecency",
"indecision",
"indecisiveness",
"indecorousness",
"indecorum",
"indefiniteness",
"indefinity",
"indelicacy",
"indemnification",
"indemnity",
"indene",
"indent",
"indentation",
"indention",
"indenture",
"independence",
"independency",
"independent",
"inderal",
"indeterminacy",
"indetermination",
"index",
"indexation",
"indexer",
"indexing",
"india",
"indiaman",
"indian",
"indiana",
"indianan",
"indianapolis",
"indic",
"indicant",
"indication",
"indicative",
"indicator",
"indicatoridae",
"indictability",
"indiction",
"indictment",
"indie",
"indifference",
"indigen",
"indigence",
"indigene",
"indigenousness",
"indigestibility",
"indigestion",
"indigirka",
"indignation",
"indignity",
"indigo",
"indigofera",
"indigotin",
"indinavir",
"indirection",
"indirectness",
"indiscipline",
"indiscreetness",
"indiscretion",
"indisposition",
"indisputability",
"indistinctness",
"indium",
"individual",
"individualism",
"individualist",
"individuality",
"individuation",
"indochina",
"indocin",
"indoctrination",
"indolence",
"indomethacin",
"indomitability",
"indonesia",
"indonesian",
"indorsement",
"indorser",
"indra",
"indri",
"indriidae",
"indris",
"indubitability",
"inducement",
"inducer",
"inducing",
"inductance",
"inductee",
"induction",
"inductor",
"indulgence",
"indulging",
"indument",
"indumentum",
"induration",
"indus",
"indusium",
"industrialism",
"industrialist",
"industriousness",
"industry",
"indweller",
"inebriant",
"inebriate",
"inebriation",
"inebriety",
"ineffectiveness",
"ineffectuality",
"ineffectualness",
"inefficacy",
"inefficiency",
"inelasticity",
"inelegance",
"ineligibility",
"ineluctability",
"ineptitude",
"ineptness",
"inequality",
"inequity",
"inerrancy",
"inertia",
"inertness",
"inessential",
"inessentiality",
"inevitability",
"inevitable",
"inevitableness",
"inexactitude",
"inexactness",
"inexorability",
"inexorableness",
"inexpedience",
"inexpediency",
"inexpensiveness",
"inexperience",
"inexplicitness",
"infallibility",
"infamy",
"infancy",
"infant",
"infanticide",
"infantilism",
"infantry",
"infantryman",
"infarct",
"infarction",
"infatuation",
"infeasibility",
"infection",
"infelicity",
"inference",
"inferior",
"inferiority",
"infernal",
"inferno",
"infertility",
"infestation",
"infidel",
"infidelity",
"infield",
"infielder",
"infiltration",
"infiltrator",
"infinite",
"infiniteness",
"infinitesimal",
"infinitive",
"infinitude",
"infinity",
"infirmary",
"infirmity",
"infix",
"inflaming",
"inflammability",
"inflammation",
"inflater",
"inflation",
"inflator",
"inflection",
"inflexibility",
"inflexibleness",
"inflexion",
"infliction",
"infliximab",
"inflorescence",
"inflow",
"influence",
"influenza",
"influx",
"info",
"infolding",
"infomercial",
"informality",
"informant",
"informatics",
"information",
"informer",
"informercial",
"informing",
"infotainment",
"infraction",
"infrared",
"infrastructure",
"infrequency",
"infrigidation",
"infringement",
"infructescence",
"infundibulum",
"infuriation",
"infusion",
"infusoria",
"infusorian",
"inga",
"ingathering",
"inge",
"ingeniousness",
"ingenue",
"ingenuity",
"ingenuousness",
"inger",
"ingerman",
"ingesta",
"ingestion",
"inglenook",
"ingot",
"ingraining",
"ingrate",
"ingratiation",
"ingratitude",
"ingredient",
"ingres",
"ingress",
"ingrian",
"ingroup",
"ingrowth",
"inguen",
"inhabitancy",
"inhabitant",
"inhabitation",
"inhalant",
"inhalation",
"inhalator",
"inhaler",
"inherence",
"inherency",
"inheritance",
"inheritor",
"inheritress",
"inheritrix",
"inhibition",
"inhibitor",
"inhomogeneity",
"inhospitality",
"inhumaneness",
"inhumanity",
"inhumation",
"inion",
"iniquity",
"initial",
"initialisation",
"initialism",
"initialization",
"initiate",
"initiation",
"initiative",
"initiator",
"injectant",
"injection",
"injector",
"injudiciousness",
"injun",
"injunction",
"injuriousness",
"injury",
"injustice",
"inka",
"inkberry",
"inkblot",
"inkiness",
"inkle",
"inkling",
"inkpad",
"inkpot",
"inkstand",
"inkwell",
"inla",
"inlay",
"inlet",
"inmarriage",
"inmate",
"innards",
"innateness",
"innersole",
"innervation",
"inning",
"innings",
"innkeeper",
"innocence",
"innocency",
"innocense",
"innocent",
"innovation",
"innovativeness",
"innovator",
"innsbruck",
"innuendo",
"innumerableness",
"inocor",
"inoculant",
"inoculating",
"inoculation",
"inoculator",
"inoculum",
"inopportuneness",
"inordinateness",
"inosculation",
"inosine",
"inositol",
"inpatient",
"inpour",
"inpouring",
"input",
"inquest",
"inquietude",
"inquirer",
"inquiring",
"inquiry",
"inquisition",
"inquisitiveness",
"inquisitor",
"inroad",
"inrush",
"insalubrity",
"insaneness",
"insanity",
"inscription",
"inscrutability",
"insect",
"insecta",
"insecticide",
"insectifuge",
"insectivora",
"insectivore",
"insecureness",
"insecurity",
"insemination",
"insensibility",
"insensitiveness",
"insensitivity",
"insentience",
"insert",
"insertion",
"insessores",
"inset",
"inside",
"insider",
"insidiousness",
"insight",
"insightfulness",
"insignia",
"insignificance",
"insincerity",
"insinuation",
"insipidity",
"insipidness",
"insistence",
"insistency",
"insisting",
"insobriety",
"insolation",
"insole",
"insolence",
"insolubility",
"insolvency",
"insolvent",
"insomnia",
"insomniac",
"insouciance",
"inspection",
"inspector",
"inspectorate",
"inspectorship",
"inspiration",
"inspirer",
"inspissation",
"instability",
"installation",
"installing",
"installment",
"instalment",
"instance",
"instancy",
"instant",
"instantiation",
"instar",
"instauration",
"instep",
"instigant",
"instigation",
"instigator",
"instillation",
"instillator",
"instilling",
"instillment",
"instilment",
"instinct",
"institute",
"institution",
"instroke",
"instruction",
"instructions",
"instructor",
"instructorship",
"instructress",
"instrument",
"instrumentalism",
"instrumentalist",
"instrumentality",
"instrumentation",
"insubordination",
"insufficiency",
"insufflation",
"insulant",
"insularism",
"insularity",
"insulation",
"insulator",
"insulin",
"insult",
"insurability",
"insurance",
"insured",
"insurer",
"insurgence",
"insurgency",
"insurgent",
"insurrection",
"insurrectionism",
"insurrectionist",
"intactness",
"intaglio",
"intake",
"intangibility",
"intangible",
"intangibleness",
"integer",
"integral",
"integrality",
"integrating",
"integration",
"integrator",
"integrity",
"integument",
"intellect",
"intellection",
"intellectual",
"intelligence",
"intelligentsia",
"intelligibility",
"intelnet",
"intemperance",
"intemperateness",
"intensification",
"intensifier",
"intension",
"intensity",
"intensive",
"intensiveness",
"intent",
"intention",
"intentionality",
"intentness",
"interaction",
"interahamwe",
"interbrain",
"interbreeding",
"intercalation",
"intercept",
"interception",
"interceptor",
"intercession",
"intercessor",
"interchange",
"intercom",
"intercommunion",
"interconnection",
"intercostal",
"intercourse",
"interdependence",
"interdependency",
"interdict",
"interdiction",
"interest",
"interestedness",
"interestingness",
"interface",
"interference",
"interferometer",
"interferon",
"interim",
"interior",
"interjection",
"interlaken",
"interlanguage",
"interlayer",
"interleaf",
"interleukin",
"interlingua",
"interlock",
"interlocking",
"interlocutor",
"interloper",
"interlude",
"intermarriage",
"intermediary",
"intermediate",
"intermediation",
"intermediator",
"interment",
"intermezzo",
"intermission",
"intermittence",
"intermittency",
"intermixture",
"intern",
"internalisation",
"internality",
"internalization",
"international",
"internationale",
"interne",
"internee",
"internet",
"internist",
"internment",
"internode",
"internship",
"internuncio",
"interoception",
"interoceptor",
"interpellation",
"interphone",
"interplay",
"interpol",
"interpolation",
"interposition",
"interpretation",
"interpreter",
"interpreting",
"interreflection",
"interregnum",
"interrelation",
"interrogation",
"interrogative",
"interrogator",
"interrogatory",
"interrupt",
"interrupter",
"interruption",
"intersection",
"intersex",
"interspersal",
"interspersion",
"interstate",
"interstice",
"intertrigo",
"interval",
"intervenor",
"intervention",
"interview",
"interviewee",
"interviewer",
"intestacy",
"intestine",
"inti",
"intifada",
"intifadah",
"intima",
"intimacy",
"intimate",
"intimation",
"intimidation",
"intolerance",
"intonation",
"intoxicant",
"intoxication",
"intractability",
"intractableness",
"intrados",
"intranet",
"intransigence",
"intransigency",
"intransitive",
"intransitivity",
"intravasation",
"intrenchment",
"intrepidity",
"intricacy",
"intrigue",
"intriguer",
"intro",
"introduction",
"introit",
"introitus",
"introject",
"introjection",
"intromission",
"intron",
"intropin",
"introspection",
"introversion",
"introvert",
"intruder",
"intrusion",
"intrusiveness",
"intubation",
"intuition",
"intuitionism",
"intumescence",
"intumescency",
"intussusception",
"inuit",
"inula",
"inulin",
"inunction",
"inundation",
"inutility",
"invader",
"invagination",
"invalid",
"invalidation",
"invalidator",
"invalidism",
"invalidity",
"invalidness",
"invaluableness",
"invar",
"invariability",
"invariable",
"invariableness",
"invariance",
"invariant",
"invasion",
"invective",
"invention",
"inventiveness",
"inventor",
"inventory",
"inventorying",
"inverse",
"inversion",
"invertase",
"invertebrate",
"inverter",
"investigating",
"investigation",
"investigator",
"investing",
"investiture",
"investment",
"investor",
"invidia",
"invigilation",
"invigilator",
"invigoration",
"invigorator",
"invincibility",
"invirase",
"invisibility",
"invisibleness",
"invitation",
"invite",
"invitee",
"invocation",
"invoice",
"involucre",
"involuntariness",
"involution",
"involvement",
"invulnerability",
"inwardness",
"iodide",
"iodin",
"iodination",
"iodine",
"iodocompound",
"iodoform",
"iodoprotein",
"iodopsin",
"iodothyronine",
"iodotyrosine",
"ionesco",
"ionia",
"ionian",
"ionic",
"ionisation",
"ionization",
"ionophoresis",
"ionosphere",
"iontophoresis",
"iontotherapy",
"iota",
"iowa",
"iowan",
"ioway",
"ipecac",
"iphigenia",
"ipidae",
"ipod",
"ipomoea",
"iproclozide",
"ipsedixitism",
"ipsus",
"irak",
"iraki",
"iran",
"irani",
"iranian",
"iraq",
"iraqi",
"irascibility",
"ireland",
"irelander",
"irena",
"irenaeus",
"irenidae",
"iresine",
"iridaceae",
"iridectomy",
"iridescence",
"iridium",
"iridocyclitis",
"iridokeratitis",
"iridoncus",
"iridoprocne",
"iridosmine",
"iridotomy",
"iris",
"irish",
"irishman",
"irishwoman",
"iritis",
"iron",
"ironclad",
"ironing",
"ironist",
"ironman",
"ironmonger",
"ironmongery",
"irons",
"ironside",
"ironsides",
"ironware",
"ironweed",
"ironwood",
"ironwork",
"ironworker",
"ironworks",
"irony",
"iroquoian",
"iroquois",
"irradiation",
"irrational",
"irrationality",
"irrawaddy",
"irreality",
"irredenta",
"irredentism",
"irredentist",
"irregular",
"irregularity",
"irrelevance",
"irrelevancy",
"irreligion",
"irreligionist",
"irreligiousness",
"irresistibility",
"irresoluteness",
"irresolution",
"irreverence",
"irreversibility",
"irridenta",
"irridentism",
"irridentist",
"irrigation",
"irritability",
"irritant",
"irritation",
"irruption",
"irtish",
"irtysh",
"irula",
"irving",
"irvingia",
"isaac",
"isabella",
"isaiah",
"isarithm",
"isatis",
"ischaemia",
"ischemia",
"ischia",
"ischigualastia",
"ischium",
"isere",
"iseult",
"isfahan",
"isherwood",
"ishmael",
"ishtar",
"isinglass",
"isis",
"iskcon",
"islam",
"islamabad",
"islamism",
"islamist",
"islamophobia",
"island",
"islander",
"islay",
"isle",
"islet",
"ismaili",
"ismailian",
"ismailism",
"isoagglutinin",
"isoagglutinogen",
"isoantibody",
"isobar",
"isobutylene",
"isocarboxazid",
"isochrone",
"isoclinal",
"isocrates",
"isocyanate",
"isoetaceae",
"isoetales",
"isoetes",
"isoflurane",
"isogamete",
"isogamy",
"isogon",
"isogone",
"isogram",
"isohel",
"isolation",
"isolationism",
"isolationist",
"isolde",
"isoleucine",
"isomer",
"isomerase",
"isomerisation",
"isomerism",
"isomerization",
"isometric",
"isometrics",
"isometropia",
"isometry",
"isomorphism",
"isomorphy",
"isoniazid",
"isopleth",
"isopod",
"isopoda",
"isopropanol",
"isoproterenol",
"isoptera",
"isoptin",
"isopyrum",
"isordil",
"isosorbide",
"isospondyli",
"isostasy",
"isotherm",
"isothiocyanate",
"isotope",
"isotropy",
"israel",
"israeli",
"israelite",
"israelites",
"issachar",
"issuance",
"issue",
"issuer",
"issuing",
"issus",
"istanbul",
"isthmus",
"istiophoridae",
"istiophorus",
"isuprel",
"isuridae",
"isurus",
"italia",
"italian",
"italic",
"italy",
"itch",
"itchiness",
"itching",
"item",
"itemisation",
"itemization",
"iteration",
"iterative",
"ithaca",
"ithaki",
"ithunn",
"itinerant",
"itinerary",
"itineration",
"itraconazole",
"ivanov",
"ives",
"ivory",
"ivorybill",
"ivry",
"ixia",
"ixobrychus",
"ixodes",
"ixodid",
"ixodidae",
"iyar",
"iyyar",
"izanagi",
"izanami",
"izar",
"izmir",
"izzard",
"jabalpur",
"jabber",
"jabberer",
"jabbering",
"jabberwocky",
"jabbing",
"jabiru",
"jaboncillo",
"jabot",
"jaboticaba",
"jacamar",
"jacaranda",
"jacinth",
"jack",
"jackal",
"jackanapes",
"jackass",
"jackboot",
"jackdaw",
"jacket",
"jackfruit",
"jackhammer",
"jackknife",
"jacklight",
"jackpot",
"jackrabbit",
"jacks",
"jackscrew",
"jacksmelt",
"jacksnipe",
"jackson",
"jacksonia",
"jacksonian",
"jacksonville",
"jackstones",
"jackstraw",
"jackstraws",
"jacob",
"jacobean",
"jacobi",
"jacobin",
"jacobinism",
"jacobite",
"jacobs",
"jaconet",
"jacquard",
"jacquinia",
"jactation",
"jactitation",
"jaculus",
"jade",
"jadeite",
"jadestone",
"jaeger",
"jafar",
"jaffa",
"jaffar",
"jagannath",
"jagannatha",
"jagatai",
"jagganath",
"jaggary",
"jaggedness",
"jagger",
"jaggery",
"jagghery",
"jaghatai",
"jagua",
"jaguar",
"jaguarondi",
"jaguarundi",
"jahvey",
"jahweh",
"jail",
"jailbird",
"jailbreak",
"jailer",
"jailhouse",
"jailor",
"jainism",
"jainist",
"jakarta",
"jakes",
"jakobson",
"jalalabad",
"jalapeno",
"jalopy",
"jalousie",
"jamaica",
"jamaican",
"jamb",
"jambalaya",
"jambeau",
"jamberry",
"jambon",
"jamboree",
"jambos",
"jambosa",
"james",
"jamesonia",
"jamestown",
"jamison",
"jamjar",
"jammer",
"jammies",
"jamming",
"jampan",
"jampot",
"jangle",
"janissary",
"janitor",
"jansen",
"jansenism",
"jansenist",
"january",
"janus",
"japan",
"japanese",
"jape",
"japery",
"japheth",
"japonica",
"jarful",
"jargon",
"jargoon",
"jarrell",
"jasmine",
"jasminum",
"jason",
"jasper",
"jaspers",
"jassid",
"jassidae",
"jati",
"jatropha",
"jaundice",
"jaunt",
"jauntiness",
"java",
"javan",
"javanese",
"javanthropus",
"javelin",
"javelina",
"jawan",
"jawbone",
"jawbreaker",
"jawfish",
"jaybird",
"jayshullah",
"jaywalker",
"jazz",
"jazzman",
"jdam",
"jealousy",
"jean",
"jeans",
"jeddah",
"jeep",
"jeer",
"jeerer",
"jeering",
"jeffers",
"jefferson",
"jeffersonian",
"jehad",
"jehovah",
"jejuneness",
"jejunitis",
"jejunity",
"jejunoileitis",
"jejunostomy",
"jejunum",
"jellaba",
"jello",
"jelly",
"jellyfish",
"jellyleaf",
"jellyroll",
"jemmy",
"jena",
"jenner",
"jennet",
"jenny",
"jensen",
"jeopardy",
"jerboa",
"jeremiad",
"jeremiah",
"jerevan",
"jerez",
"jericho",
"jerk",
"jerker",
"jerkin",
"jerkiness",
"jerking",
"jerky",
"jeroboam",
"jerome",
"jerry",
"jersey",
"jerusalem",
"jespersen",
"jessamine",
"jest",
"jester",
"jesuit",
"jesuitism",
"jesuitry",
"jesus",
"jeth",
"jetliner",
"jetsam",
"jetty",
"jevons",
"jewbush",
"jewel",
"jeweler",
"jeweller",
"jewellery",
"jewelry",
"jewelweed",
"jewess",
"jewfish",
"jewison",
"jewry",
"jezebel",
"jhvh",
"jiao",
"jibboom",
"jibe",
"jidda",
"jiddah",
"jiffy",
"jigger",
"jiggermast",
"jiggle",
"jigsaw",
"jihad",
"jihadist",
"jillion",
"jilt",
"jimdandy",
"jimenez",
"jimhickey",
"jimmies",
"jimmy",
"jimsonweed",
"jinghpaw",
"jinghpo",
"jingle",
"jingo",
"jingoism",
"jingoist",
"jinja",
"jinks",
"jinnah",
"jinnee",
"jinni",
"jinrikisha",
"jinx",
"jiqui",
"jird",
"jirga",
"jirrbal",
"jitney",
"jitter",
"jitterbug",
"jitteriness",
"jitters",
"jiujitsu",
"jive",
"joachim",
"jobber",
"jobbery",
"jobcentre",
"jobholder",
"jocasta",
"jock",
"jockey",
"jockstrap",
"jocoseness",
"jocosity",
"jocote",
"jocularity",
"jocundity",
"jodhpur",
"jodhpurs",
"joel",
"joewood",
"joffre",
"joffrey",
"jogger",
"jogging",
"joggle",
"johannesburg",
"john",
"johnny",
"johnnycake",
"johns",
"johnson",
"johnston",
"johor",
"johore",
"join",
"joiner",
"joinery",
"joining",
"joint",
"jointer",
"jointure",
"jointworm",
"joist",
"joke",
"joker",
"jokester",
"joliet",
"joliot",
"jolliet",
"jollification",
"jolliness",
"jollity",
"jolly",
"jolson",
"jolt",
"jonah",
"jonathan",
"jones",
"jonesboro",
"jong",
"jongleur",
"jonquil",
"jonson",
"jook",
"joplin",
"joppa",
"jordan",
"jordanella",
"jordanian",
"jorum",
"joseph",
"josephus",
"joshua",
"joss",
"jostle",
"jostling",
"josue",
"jotter",
"jotting",
"jotun",
"jotunn",
"joule",
"jounce",
"journal",
"journalese",
"journalism",
"journalist",
"journey",
"journeyer",
"journeying",
"journeyman",
"joust",
"jove",
"joviality",
"jowett",
"jowl",
"joyce",
"joyfulness",
"joylessness",
"joyousness",
"joyride",
"joystick",
"juarez",
"jubbulpore",
"jubilance",
"jubilancy",
"jubilation",
"jubilee",
"juda",
"judaea",
"judah",
"judaica",
"judaism",
"judas",
"jude",
"judea",
"judge",
"judgement",
"judges",
"judgeship",
"judging",
"judgment",
"judicatory",
"judicature",
"judiciary",
"judiciousness",
"judith",
"judo",
"jugale",
"jugful",
"juggernaut",
"juggle",
"juggler",
"jugglery",
"juggling",
"juglandaceae",
"juglandales",
"juglans",
"jugoslav",
"jugoslavian",
"jugoslavija",
"jugular",
"juice",
"juicer",
"juiciness",
"jujitsu",
"juju",
"jujube",
"jujutsu",
"juke",
"jukebox",
"julep",
"julian",
"julienne",
"july",
"jumbal",
"jumble",
"jumbojet",
"jument",
"jump",
"jumper",
"jumpiness",
"jumping",
"jumpstart",
"jumpsuit",
"juncaceae",
"juncaginaceae",
"junco",
"junction",
"juncture",
"juncus",
"june",
"juneau",
"juneberry",
"jung",
"jungermanniales",
"jungian",
"jungle",
"junior",
"juniper",
"juniperus",
"junk",
"junker",
"junkers",
"junket",
"junketing",
"junkie",
"junky",
"junkyard",
"juno",
"junta",
"junto",
"jupati",
"jupaty",
"jupiter",
"jurassic",
"jurisdiction",
"jurisprudence",
"jurist",
"juror",
"jury",
"juryman",
"jurywoman",
"jussieu",
"justice",
"justiciar",
"justiciary",
"justification",
"justifier",
"justinian",
"justness",
"jute",
"jutish",
"jutland",
"jutting",
"juvenal",
"juvenescence",
"juvenile",
"juvenility",
"juxtaposition",
"jyaistha",
"jylland",
"jynx",
"kaaba",
"kabala",
"kabbala",
"kabbalah",
"kabbalism",
"kabbalist",
"kabob",
"kabolin",
"kabul",
"kach",
"kachaturian",
"kachin",
"kachina",
"kachinic",
"kadai",
"kadikoy",
"kaffir",
"kaffiyeh",
"kafir",
"kafiri",
"kafka",
"kafocin",
"kaftan",
"kahikatea",
"kahlua",
"kahn",
"kahoolawe",
"kail",
"kainite",
"kainogenesis",
"kaiser",
"kakatoe",
"kakemono",
"kaki",
"kalahari",
"kalamazoo",
"kalansuwa",
"kalantas",
"kalapooia",
"kalapooian",
"kalapuya",
"kalapuyan",
"kalashnikov",
"kale",
"kaleidoscope",
"kalemia",
"kali",
"kalian",
"kalif",
"kalimantan",
"kalinin",
"kaliph",
"kaliuresis",
"kalka",
"kalki",
"kalmia",
"kalotermes",
"kalotermitidae",
"kalpac",
"kaluga",
"kalumpang",
"kaluresis",
"kama",
"kamarupan",
"kamasutra",
"kamba",
"kameez",
"kamet",
"kami",
"kamia",
"kamikaze",
"kampala",
"kampong",
"kampuchea",
"kampuchean",
"kanaf",
"kanamycin",
"kananga",
"kanara",
"kanarese",
"kanawha",
"kanchanjanga",
"kanchenjunga",
"kanchil",
"kandahar",
"kandinski",
"kandinsky",
"kandy",
"kangaroo",
"kannada",
"kansa",
"kansan",
"kansas",
"kansu",
"kant",
"kantrex",
"kanzu",
"kaochlor",
"kaoliang",
"kaolin",
"kaoline",
"kaolinite",
"kaon",
"kaopectate",
"kapeika",
"kaph",
"kapok",
"kappa",
"kapsiki",
"kapuka",
"karabiner",
"karachi",
"karaites",
"karakalpak",
"karakoram",
"karakul",
"karaoke",
"karat",
"karate",
"karbala",
"karelia",
"karelian",
"karen",
"karenic",
"karlfeldt",
"karloff",
"karma",
"karnataka",
"karok",
"karpov",
"karsavina",
"kartik",
"kartikeya",
"karttika",
"karttikeya",
"karyokinesis",
"karyolymph",
"karyolysis",
"karyon",
"karyoplasm",
"karyotype",
"kasai",
"kasbah",
"kasha",
"kashag",
"kashmir",
"kashmiri",
"kasparov",
"kassite",
"kastler",
"katabolism",
"katamorphism",
"katar",
"katari",
"katharevusa",
"katharobe",
"katharometer",
"katharsis",
"kathmandu",
"katmandu",
"katowice",
"katsina",
"katsuwonidae",
"katsuwonus",
"kattegatt",
"katydid",
"katzenjammer",
"kauai",
"kaufman",
"kaunas",
"kaunda",
"kauri",
"kaury",
"kava",
"kavakava",
"kavrin",
"kawaka",
"kayak",
"kayo",
"kazak",
"kazakh",
"kazakhstan",
"kazakhstani",
"kazakstan",
"kazan",
"kazoo",
"kbit",
"kean",
"keaton",
"keats",
"kebab",
"keble",
"kechua",
"kechuan",
"kedah",
"kedgeree",
"keel",
"keelboat",
"keelson",
"keen",
"keenness",
"keep",
"keeper",
"keeping",
"keepsake",
"keeshond",
"keflex",
"keflin",
"keftab",
"kegful",
"keister",
"kekchi",
"kekule",
"kelantan",
"keller",
"kellogg",
"kelly",
"keloid",
"kelp",
"kelpie",
"kelpwort",
"kelpy",
"kelt",
"kelter",
"kelvin",
"kemadrin",
"kenaf",
"kenalog",
"kendal",
"kendall",
"kendrew",
"kennan",
"kennedia",
"kennedy",
"kennedya",
"kennel",
"kennelly",
"kennewick",
"kenning",
"keno",
"kenogenesis",
"kenosis",
"kent",
"kentan",
"kentish",
"kentuckian",
"kentucky",
"kenya",
"kenyan",
"kenyapithecus",
"kenyata",
"keokuk",
"kepi",
"kepler",
"kera",
"keratalgia",
"keratectasia",
"keratin",
"keratinisation",
"keratinization",
"keratitis",
"keratoacanthoma",
"keratocele",
"keratoconus",
"keratoderma",
"keratodermia",
"keratohyalin",
"keratoiritis",
"keratomalacia",
"keratomycosis",
"keratonosis",
"keratonosus",
"keratoplasty",
"keratoscleritis",
"keratoscope",
"keratoscopy",
"keratosis",
"keratotomy",
"kerb",
"kerbala",
"kerbela",
"kerbstone",
"kerchief",
"kerensky",
"kerfuffle",
"kerion",
"kern",
"kernel",
"kernicterus",
"kernite",
"kerosene",
"kerosine",
"kerouac",
"kerugma",
"kerygma",
"kesey",
"kestrel",
"ketalar",
"ketamine",
"ketch",
"ketchup",
"keteleeria",
"ketembilla",
"ketoacidosis",
"ketoaciduria",
"ketohexose",
"ketone",
"ketonemia",
"ketonuria",
"ketoprofen",
"ketorolac",
"ketose",
"ketosis",
"ketosteroid",
"kettering",
"kettle",
"kettledrum",
"kettleful",
"ketubim",
"keurboom",
"keyboard",
"keyboardist",
"keycard",
"keyhole",
"keynes",
"keynesian",
"keynesianism",
"keynote",
"keypad",
"keystone",
"keystroke",
"khabarovsk",
"khachaturian",
"khadafy",
"khaddar",
"khadi",
"khaki",
"khakis",
"khalif",
"khalifah",
"khalka",
"khalkha",
"khalsa",
"khama",
"khamsin",
"khamti",
"khan",
"khanate",
"khanty",
"kharkiv",
"kharkov",
"khartoum",
"khat",
"khaya",
"khedive",
"khepera",
"khesari",
"khimar",
"khios",
"khirghiz",
"khmer",
"khoikhoi",
"khoikhoin",
"khoisan",
"khomeini",
"khoum",
"khowar",
"khrushchev",
"khuen",
"khufu",
"khukuri",
"kiaat",
"kiang",
"kibble",
"kibbutz",
"kibbutznik",
"kibe",
"kibibit",
"kibibyte",
"kibit",
"kibitzer",
"kichaga",
"kichai",
"kick",
"kickapoo",
"kickback",
"kicker",
"kicking",
"kickoff",
"kickshaw",
"kicksorter",
"kickstand",
"kidd",
"kiddie",
"kiddy",
"kidnaper",
"kidnapper",
"kidnapping",
"kidney",
"kidskin",
"kierkegaard",
"kieselguhr",
"kieserite",
"kieslowski",
"kiev",
"kigali",
"kiggelaria",
"kike",
"kikladhes",
"kildeer",
"kilderkin",
"kiley",
"kilimanjaro",
"kiliwa",
"kiliwi",
"kill",
"killdeer",
"killer",
"killifish",
"killing",
"killjoy",
"kiln",
"kilo",
"kilobit",
"kilobyte",
"kilocalorie",
"kilocycle",
"kilogram",
"kilohertz",
"kiloliter",
"kilolitre",
"kilometer",
"kilometre",
"kiloton",
"kilovolt",
"kilowatt",
"kilroy",
"kilt",
"kilter",
"kimberley",
"kimberlite",
"kimono",
"kina",
"kinaesthesia",
"kinaesthesis",
"kinanesthesia",
"kinase",
"kinchinjunga",
"kind",
"kindergarten",
"kindergartener",
"kindergartner",
"kindheartedness",
"kindliness",
"kindling",
"kindness",
"kindred",
"kine",
"kinematics",
"kinescope",
"kinesiology",
"kinesis",
"kinesthesia",
"kinesthesis",
"kinesthetics",
"kinetics",
"kinetochore",
"kinetoscope",
"kinetosis",
"kinfolk",
"king",
"kingbird",
"kingbolt",
"kingcup",
"kingdom",
"kingfish",
"kingfisher",
"kinglet",
"kingmaker",
"kingpin",
"kingship",
"kingsnake",
"kingston",
"kingstown",
"kingwood",
"kinin",
"kink",
"kinkajou",
"kino",
"kinosternidae",
"kinosternon",
"kinsey",
"kinsfolk",
"kinshasa",
"kinship",
"kinsman",
"kinsperson",
"kinswoman",
"kinyarwanda",
"kiosk",
"kiowa",
"kipling",
"kipper",
"kirchhoff",
"kirchner",
"kirghiz",
"kirghizia",
"kirghizstan",
"kirgiz",
"kirgizia",
"kirgizstan",
"kiribati",
"kirk",
"kirkia",
"kirkuk",
"kirpan",
"kirsch",
"kirtle",
"kishar",
"kishinev",
"kishke",
"kislev",
"kismat",
"kismet",
"kiss",
"kisser",
"kissimmee",
"kissing",
"kissinger",
"kisumu",
"kiswahili",
"kitakyushu",
"kitambilla",
"kitbag",
"kitchen",
"kitchener",
"kitchenette",
"kitchenware",
"kite",
"kitembilla",
"kith",
"kitsch",
"kittee",
"kitten",
"kittiwake",
"kittul",
"kitty",
"kitul",
"kivu",
"kiwi",
"klaipeda",
"klamath",
"klan",
"klansman",
"klaproth",
"klavern",
"klavier",
"klaxon",
"klebsiella",
"klee",
"kleenex",
"klein",
"kleist",
"kleptomania",
"kleptomaniac",
"klick",
"klimt",
"kline",
"klinefelter",
"klondike",
"klopstock",
"klorvess",
"klotho",
"kludge",
"klutz",
"kluxer",
"klystron",
"klyuchevskaya",
"knack",
"knacker",
"knackwurst",
"knapsack",
"knapweed",
"knave",
"knavery",
"knawe",
"knawel",
"knee",
"kneecap",
"kneel",
"kneeler",
"kneeling",
"kneepan",
"knell",
"knesset",
"knesseth",
"knickerbockers",
"knickers",
"knickknack",
"knickknackery",
"knife",
"knight",
"knighthood",
"knightia",
"knightliness",
"kniphofia",
"knish",
"knit",
"knitter",
"knitting",
"knitwear",
"knitwork",
"knob",
"knobble",
"knobkerrie",
"knobkerry",
"knock",
"knockabout",
"knockdown",
"knocker",
"knocking",
"knockoff",
"knockout",
"knockwurst",
"knoll",
"knossos",
"knot",
"knotgrass",
"knothole",
"knottiness",
"knout",
"know",
"knower",
"knowing",
"knowingness",
"knowledge",
"knox",
"knoxville",
"knuckle",
"knuckleball",
"knucklebones",
"knucklehead",
"knuckler",
"knuckles",
"knucks",
"knut",
"koala",
"koan",
"koasati",
"kobe",
"kobenhavn",
"kobo",
"kobus",
"koch",
"kochia",
"kodiak",
"koellia",
"koestler",
"kogia",
"kohl",
"kohleria",
"kohlrabi",
"koine",
"koinonia",
"kokka",
"kola",
"kolam",
"kolami",
"kolkata",
"kolkhoz",
"kolkhoznik",
"kolkwitzia",
"koln",
"kolonia",
"komi",
"komondor",
"konakri",
"kongfuze",
"kongo",
"konini",
"konoe",
"konoye",
"konqueror",
"koodoo",
"kook",
"kookaburra",
"koopmans",
"kopeck",
"kopek",
"kopiyka",
"kopje",
"koppie",
"koran",
"korbut",
"korchnoi",
"korda",
"kordofan",
"kordofanian",
"kore",
"korea",
"korean",
"korinthos",
"koruna",
"korzybski",
"kosciusko",
"kosciuszko",
"kosher",
"kosovo",
"kosteletzya",
"kota",
"kotar",
"kotex",
"koto",
"kotoko",
"kotow",
"koudou",
"koumiss",
"koussevitzky",
"kovna",
"kovno",
"koweit",
"kowhai",
"kowtow",
"kraal",
"kraft",
"krait",
"krakatao",
"krakatau",
"krakatoa",
"krakau",
"krakow",
"krasner",
"kraurosis",
"kraut",
"krauthead",
"krebs",
"kreisler",
"kremlin",
"krigia",
"krill",
"kris",
"krishna",
"krishnaism",
"kriti",
"kroeber",
"krona",
"krone",
"kronecker",
"kroon",
"kropotkin",
"kroto",
"krubi",
"kruger",
"krummhorn",
"krupp",
"krypton",
"kshatriya",
"kuangchou",
"kubrick",
"kuchean",
"kudos",
"kudu",
"kudzu",
"kuenlun",
"kuhn",
"kuiper",
"kukenaam",
"kuki",
"kulanapan",
"kulun",
"kumasi",
"kumis",
"kummel",
"kumquat",
"kunlun",
"kunzite",
"kuomintang",
"kura",
"kurakkan",
"kurchee",
"kurchi",
"kurd",
"kurdish",
"kurdistan",
"kurosawa",
"kuroshio",
"kurrajong",
"kurrat",
"kursk",
"kurta",
"kuru",
"kurus",
"kurux",
"kusan",
"kutch",
"kutuzov",
"kuvasz",
"kuvi",
"kuwait",
"kuwaiti",
"kuznets",
"kvass",
"kvetch",
"kwacha",
"kwai",
"kwajalein",
"kwakiutl",
"kwangchow",
"kwangju",
"kwangtung",
"kwannon",
"kwanza",
"kwanzaa",
"kwashiorkor",
"kweek",
"kwela",
"kwell",
"kyanite",
"kyat",
"kylie",
"kylix",
"kymograph",
"kyoto",
"kyphosidae",
"kyphosis",
"kyphosus",
"kyrgyzstan",
"kyushu",
"kyyiv",
"laager",
"laban",
"labanotation",
"labdanum",
"label",
"labetalol",
"labial",
"labiatae",
"labiodental",
"labium",
"lablab",
"lablink",
"labor",
"laboratory",
"laborer",
"laboriousness",
"labour",
"labourer",
"labourite",
"labrador",
"labridae",
"labrocyte",
"labrouste",
"laburnum",
"labyrinth",
"labyrinthitis",
"labyrinthodont",
"labyrinthodonta",
"laccopetalum",
"lace",
"lacebark",
"lacepod",
"lacer",
"laceration",
"lacerta",
"lacertid",
"lacertidae",
"lacertilia",
"lacewing",
"lacewood",
"lacework",
"lachaise",
"lachesis",
"lachnolaimus",
"lachrymation",
"lachrymator",
"lacing",
"lack",
"lackey",
"laconia",
"laconian",
"laconicism",
"laconism",
"lacquer",
"lacquerware",
"lacrimation",
"lacrimator",
"lacrosse",
"lactaid",
"lactalbumin",
"lactarius",
"lactase",
"lactate",
"lactation",
"lacteal",
"lactifuge",
"lactobacillus",
"lactoflavin",
"lactogen",
"lactophrys",
"lactose",
"lactosuria",
"lactuca",
"lacuna",
"lacunar",
"ladanum",
"ladder",
"laddie",
"ladin",
"lading",
"ladino",
"ladle",
"ladoga",
"lady",
"ladybeetle",
"ladybird",
"ladybug",
"ladyfinger",
"ladyfish",
"ladylikeness",
"ladylove",
"ladyship",
"laelia",
"laertes",
"laetrile",
"laevulose",
"lafayette",
"laffer",
"laffite",
"lafitte",
"lagan",
"lagarostrobus",
"lagenaria",
"lagend",
"lagenophera",
"lager",
"lagerphone",
"lagerstroemia",
"laggard",
"lagger",
"lagging",
"lagidium",
"lagniappe",
"lagodon",
"lagomorph",
"lagomorpha",
"lagoon",
"lagophthalmos",
"lagopus",
"lagorchestes",
"lagos",
"lagostomus",
"lagothrix",
"laguna",
"laguncularia",
"lagune",
"lahar",
"lahore",
"lahu",
"lair",
"laird",
"laity",
"laius",
"lake",
"lakefront",
"lakeland",
"lakeshore",
"lakeside",
"lakh",
"lakota",
"lakshmi",
"lallans",
"lallation",
"lally",
"lama",
"lamaism",
"lamaist",
"lamarck",
"lamarckian",
"lamarckism",
"lamasery",
"lamb",
"lambchop",
"lambda",
"lambdacism",
"lambency",
"lambert",
"lambertia",
"lambis",
"lambkill",
"lambkin",
"lambrequin",
"lambskin",
"lame",
"lamedh",
"lamella",
"lamellibranch",
"lamellibranchia",
"lamellicornia",
"lameness",
"lament",
"lamentation",
"lamentations",
"lamenter",
"lamia",
"lamiaceae",
"lamina",
"laminaria",
"laminariaceae",
"laminariales",
"laminate",
"lamination",
"laminator",
"laminectomy",
"laminitis",
"lamisil",
"lamium",
"lamivudine",
"lammas",
"lammastide",
"lammergeier",
"lammergeyer",
"lamna",
"lamnidae",
"lamp",
"lampblack",
"lamphouse",
"lamplight",
"lamplighter",
"lampoon",
"lampooner",
"lamppost",
"lamprey",
"lampridae",
"lampris",
"lampropeltis",
"lampshade",
"lampshell",
"lampyridae",
"lanai",
"lancashire",
"lancaster",
"lancastrian",
"lance",
"lancelet",
"lancelot",
"lancer",
"lancers",
"lancet",
"lancetfish",
"lancewood",
"lanchou",
"lanchow",
"land",
"landau",
"lander",
"landfall",
"landfill",
"landgrave",
"landholder",
"landholding",
"landing",
"landlady",
"landler",
"landline",
"landlord",
"landlubber",
"landman",
"landmark",
"landmass",
"landowner",
"landowska",
"landrover",
"landscape",
"landscaper",
"landscaping",
"landscapist",
"landside",
"landslide",
"landslip",
"landsmaal",
"landsmal",
"landsman",
"landsteiner",
"lane",
"laney",
"langbeinite",
"lange",
"langlaufer",
"langley",
"langmuir",
"langobard",
"langouste",
"langoustine",
"langsat",
"langset",
"langside",
"langsyne",
"langtry",
"language",
"languisher",
"languor",
"langur",
"laniard",
"laniidae",
"lanius",
"lankiness",
"lanolin",
"lanoxin",
"lansa",
"lansat",
"lanseh",
"lanset",
"lansing",
"lansoprazole",
"lantana",
"lantern",
"lanternfish",
"lanthanide",
"lanthanoid",
"lanthanon",
"lanthanotidae",
"lanthanotus",
"lanthanum",
"lanugo",
"lanyard",
"lanzhou",
"laocoon",
"laos",
"laotian",
"laparocele",
"laparoscope",
"laparoscopy",
"laparotomy",
"lapboard",
"lapdog",
"lapel",
"lapful",
"lapidarist",
"lapidary",
"lapidation",
"lapidator",
"lapidist",
"lapin",
"laplace",
"lapland",
"laportea",
"lapp",
"lappet",
"lappic",
"lapping",
"lappish",
"lappland",
"lapplander",
"lappula",
"lapse",
"lapsing",
"laptop",
"laputa",
"lapwing",
"laramie",
"larboard",
"larcener",
"larcenist",
"larcenous",
"larceny",
"larch",
"lard",
"larder",
"lardizabala",
"lardizabalaceae",
"lardner",
"laredo",
"large",
"largemouth",
"largeness",
"largess",
"largesse",
"larghetto",
"largo",
"lari",
"lariat",
"laricariidae",
"larid",
"laridae",
"larium",
"larix",
"lark",
"larkspur",
"larodopa",
"larotid",
"larousse",
"larrea",
"larus",
"larva",
"larvacea",
"larvacean",
"larvacide",
"larvicide",
"laryngectomy",
"laryngismus",
"laryngitis",
"laryngopharynx",
"laryngoscope",
"laryngospasm",
"laryngostenosis",
"larynx",
"lasagna",
"lasagne",
"lasalle",
"lascar",
"lascaux",
"lasciviousness",
"lasek",
"laser",
"lash",
"lasher",
"lashing",
"lashings",
"lasik",
"lasiocampa",
"lasiocampid",
"lasiocampidae",
"lasiurus",
"lasix",
"lass",
"lassa",
"lassie",
"lassitude",
"lasso",
"last",
"lastex",
"lasthenia",
"lastingness",
"lastreopsis",
"latakia",
"latanier",
"latch",
"latchet",
"latchkey",
"latchstring",
"latecomer",
"lateen",
"latency",
"lateness",
"lateral",
"lateralisation",
"laterality",
"lateralization",
"lateran",
"laterite",
"lates",
"latest",
"latex",
"lath",
"lathe",
"lathee",
"lather",
"lathi",
"lathyrus",
"laticifer",
"latimeria",
"latimeridae",
"latin",
"latinae",
"latinesce",
"latinism",
"latinist",
"latino",
"latitude",
"latitudinarian",
"latium",
"latke",
"latona",
"latria",
"latrine",
"latrobe",
"latrodectus",
"lats",
"latte",
"latten",
"latter",
"lattice",
"latticework",
"latvia",
"latvian",
"laudability",
"laudableness",
"laudanum",
"laudator",
"lauder",
"laudo",
"laugh",
"laugher",
"laughingstock",
"laughter",
"laughton",
"lauhala",
"launce",
"launch",
"launcher",
"launching",
"launchpad",
"launderette",
"laundering",
"laundress",
"laundromat",
"laundry",
"laundryman",
"laundrywoman",
"lauraceae",
"laurasia",
"laureate",
"laurel",
"laurels",
"laurelwood",
"laurens",
"laurentius",
"laurus",
"lausanne",
"lava",
"lavabo",
"lavage",
"lavalava",
"lavalier",
"lavaliere",
"lavalliere",
"lavandula",
"lavatera",
"lavation",
"lavatory",
"lavender",
"laver",
"lavishness",
"lavoisier",
"lawbreaker",
"lawcourt",
"lawfulness",
"lawgiver",
"lawlessness",
"lawmaker",
"lawmaking",
"lawman",
"lawn",
"lawrence",
"lawrencium",
"laws",
"lawsuit",
"lawton",
"lawyer",
"lawyerbush",
"laxation",
"laxative",
"laxity",
"laxness",
"layabout",
"layby",
"layer",
"layette",
"layia",
"laying",
"layman",
"layoff",
"layout",
"layover",
"layperson",
"layup",
"lazar",
"lazaret",
"lazarette",
"lazaretto",
"lazarus",
"laziness",
"lazio",
"lazuli",
"lazuline",
"lazybones",
"leach",
"leaching",
"leacock",
"lead",
"leadbelly",
"leader",
"leaders",
"leadership",
"leading",
"leadplant",
"leadwort",
"leaf",
"leafage",
"leafhopper",
"leafing",
"leaflet",
"leafstalk",
"league",
"leak",
"leakage",
"leaker",
"leakey",
"leakiness",
"lean",
"leander",
"leaner",
"leaning",
"leanness",
"leap",
"leaper",
"leapfrog",
"leaping",
"lear",
"learnedness",
"learner",
"learning",
"leary",
"lease",
"leasehold",
"leaseholder",
"leash",
"least",
"leather",
"leatherback",
"leatherette",
"leatherfish",
"leatherjack",
"leatherjacket",
"leatherleaf",
"leatherneck",
"leatherwood",
"leatherwork",
"leave",
"leaven",
"leavening",
"leaver",
"leaving",
"lebanese",
"lebanon",
"lebensraum",
"lebistes",
"lecanopteris",
"lecanora",
"lecanoraceae",
"leccinum",
"lech",
"lechanorales",
"lechatelierite",
"lecher",
"lecherousness",
"lechery",
"lechwe",
"lecithin",
"lectern",
"lectin",
"lector",
"lecture",
"lecturer",
"lectureship",
"lecturing",
"lecythidaceae",
"leda",
"ledbetter",
"lede",
"lederhosen",
"ledge",
"ledgeman",
"ledger",
"ledum",
"leech",
"leechee",
"leeds",
"leek",
"leer",
"lees",
"leeuwenhoek",
"leeward",
"leeway",
"leflunomide",
"left",
"leftfield",
"lefthander",
"leftism",
"leftist",
"leftover",
"leftovers",
"lefty",
"legacy",
"legalese",
"legalisation",
"legalism",
"legality",
"legalization",
"legate",
"legatee",
"legateship",
"legation",
"legend",
"leger",
"legerdemain",
"legerity",
"legging",
"leghorn",
"legibility",
"leging",
"legion",
"legionary",
"legionella",
"legionnaire",
"legislating",
"legislation",
"legislator",
"legislatorship",
"legislature",
"legitimacy",
"legitimation",
"lego",
"legs",
"legume",
"leguminosae",
"lehar",
"leibnitz",
"leibniz",
"leicester",
"leicestershire",
"leiden",
"leigh",
"leiomyoma",
"leiomyosarcoma",
"leiopelma",
"leiopelmatidae",
"leiophyllum",
"leipoa",
"leipzig",
"leishmania",
"leishmaniasis",
"leishmaniosis",
"leister",
"leisure",
"leisureliness",
"leitmotif",
"leitmotiv",
"leitneria",
"leitneriaceae",
"lekvar",
"lemaireocereus",
"lemaitre",
"lemanderin",
"lemma",
"lemming",
"lemmon",
"lemmus",
"lemna",
"lemnaceae",
"lemniscate",
"lemniscus",
"lemnos",
"lemon",
"lemonade",
"lemongrass",
"lemonwood",
"lempira",
"lemur",
"lemuridae",
"lemuroidea",
"lena",
"lenard",
"lender",
"lending",
"lendl",
"length",
"lengthening",
"lengthiness",
"lenience",
"leniency",
"lenin",
"leningrad",
"leninism",
"lenitive",
"lenity",
"lennoaceae",
"lennon",
"lens",
"lense",
"lensman",
"lent",
"lententide",
"lentia",
"lenticel",
"lentigo",
"lentil",
"lentinus",
"lentisk",
"leon",
"leonard",
"leonardo",
"leonberg",
"leoncita",
"leone",
"leonidas",
"leonotis",
"leontief",
"leontocebus",
"leontodon",
"leontopodium",
"leonurus",
"leopard",
"leopardbane",
"leopardess",
"leopoldville",
"leotard",
"leotards",
"lepadidae",
"lepanto",
"lepas",
"lepechinia",
"leper",
"lepidium",
"lepidobotrys",
"lepidochelys",
"lepidocrocite",
"lepidocybium",
"lepidodendrales",
"lepidolite",
"lepidomelane",
"lepidophobia",
"lepidoptera",
"lepidopteran",
"lepidopterist",
"lepidopterology",
"lepidopteron",
"lepidoptery",
"lepidosauria",
"lepidothamnus",
"lepiota",
"lepiotaceae",
"lepisma",
"lepismatidae",
"lepisosteidae",
"lepisosteus",
"lepomis",
"leporid",
"leporidae",
"leporide",
"leppy",
"leprechaun",
"leprosy",
"leptarrhena",
"leptinotarsa",
"leptocephalus",
"leptodactylid",
"leptodactylidae",
"leptodactylus",
"leptoglossus",
"leptomeninges",
"leptomeningitis",
"lepton",
"leptopteris",
"leptoptilus",
"leptospira",
"leptospirosis",
"leptosporangium",
"leptotene",
"leptotyphlops",
"lepus",
"leresis",
"lermontov",
"lerner",
"lerot",
"lesbian",
"lesbianism",
"lesbos",
"lescol",
"lesion",
"lesotho",
"lespedeza",
"lesquerella",
"lessee",
"lessening",
"lesseps",
"lessing",
"lesson",
"lessor",
"lesvos",
"letch",
"letdown",
"lethality",
"lethargy",
"lethe",
"leto",
"letter",
"lettercard",
"letterer",
"letterhead",
"lettering",
"letterman",
"letterpress",
"letters",
"letting",
"lettish",
"lettuce",
"letup",
"leucadendron",
"leucaemia",
"leucaena",
"leucanthemum",
"leucine",
"leuciscus",
"leucocyte",
"leucocytosis",
"leucocytozoan",
"leucocytozoon",
"leucogenes",
"leucoma",
"leucopenia",
"leucorrhea",
"leucothoe",
"leucotomy",
"leuctra",
"leukaemia",
"leukemia",
"leukeran",
"leukocyte",
"leukocytosis",
"leukoderma",
"leukoma",
"leukopenia",
"leukorrhea",
"leukotomy",
"leuwenhoek",
"levallorphan",
"levant",
"levanter",
"levantine",
"levator",
"levee",
"level",
"leveler",
"leveling",
"leveller",
"lever",
"leverage",
"leveraging",
"leveret",
"levi",
"leviathan",
"levirate",
"levis",
"levisticum",
"levitation",
"levite",
"leviticus",
"levitra",
"levity",
"levodopa",
"levorotation",
"levulose",
"levy",
"lewdness",
"lewis",
"lewisia",
"lewiston",
"lexeme",
"lexicalisation",
"lexicalization",
"lexicographer",
"lexicography",
"lexicologist",
"lexicology",
"lexicon",
"lexington",
"lexis",
"leycesteria",
"leyden",
"leymus",
"leyte",
"lhasa",
"lhotse",
"liabilities",
"liability",
"liaison",
"liakoura",
"liana",
"liao",
"liar",
"liatris",
"libation",
"libber",
"libby",
"libel",
"libeler",
"liberal",
"liberalisation",
"liberalism",
"liberalist",
"liberality",
"liberalization",
"liberalness",
"liberation",
"liberator",
"liberia",
"liberian",
"libertarian",
"libertarianism",
"libertine",
"liberty",
"libido",
"libocedrus",
"libra",
"librarian",
"librarianship",
"library",
"libration",
"librettist",
"libretto",
"libreville",
"libritabs",
"librium",
"libya",
"libyan",
"licence",
"license",
"licensee",
"licenser",
"licentiate",
"licentiousness",
"lichanura",
"lichee",
"lichen",
"lichenales",
"lichenes",
"lichgate",
"lichi",
"lichtenstein",
"licitness",
"lick",
"licking",
"licorice",
"lidar",
"lido",
"lidocaine",
"liebfraumilch",
"liechtenstein",
"liechtensteiner",
"lied",
"liederkranz",
"liege",
"liegeman",
"lien",
"liepaja",
"lietuva",
"lieu",
"lieutenancy",
"lieutenant",
"life",
"lifeblood",
"lifeboat",
"lifeguard",
"lifelessness",
"lifeline",
"lifer",
"lifesaver",
"lifesaving",
"lifespan",
"lifestyle",
"lifetime",
"lifework",
"lifo",
"lift",
"lifter",
"liftgate",
"liftman",
"liftoff",
"ligament",
"ligan",
"ligand",
"ligation",
"ligature",
"liger",
"light",
"lightbulb",
"lightening",
"lighter",
"lighterage",
"lighterman",
"lightheadedness",
"lighthouse",
"lighting",
"lightlessness",
"lightness",
"lightning",
"lightship",
"lightsomeness",
"lightweight",
"lightwood",
"ligne",
"lignin",
"lignite",
"lignosae",
"lignum",
"ligularia",
"ligule",
"liguria",
"ligustrum",
"like",
"likelihood",
"likeliness",
"likeness",
"likening",
"liking",
"likuta",
"lilac",
"lilangeni",
"liliaceae",
"liliales",
"liliidae",
"liliopsid",
"liliopsida",
"lilith",
"lilium",
"liliuokalani",
"lille",
"lillie",
"lilliput",
"lilliputian",
"lilo",
"lilongwe",
"lilt",
"lily",
"lilyturf",
"lima",
"limacidae",
"liman",
"limanda",
"limax",
"limb",
"limber",
"limbers",
"limbo",
"limburger",
"limbus",
"lime",
"limeade",
"limeira",
"limekiln",
"limelight",
"limen",
"limenitis",
"limerick",
"limestone",
"limewater",
"limey",
"limicolae",
"limit",
"limitation",
"limited",
"limiter",
"limiting",
"limitlessness",
"limner",
"limning",
"limnobium",
"limnocryptes",
"limnodromus",
"limnologist",
"limnology",
"limnos",
"limo",
"limonene",
"limonite",
"limonium",
"limosa",
"limousin",
"limousine",
"limp",
"limpa",
"limper",
"limpet",
"limpidity",
"limping",
"limpkin",
"limpness",
"limpopo",
"limulidae",
"limulus",
"linac",
"linaceae",
"linage",
"linalool",
"linanthus",
"linaria",
"linchpin",
"lincocin",
"lincoln",
"lincolnshire",
"lincomycin",
"lind",
"lindane",
"lindbergh",
"linden",
"lindera",
"lindesnes",
"lindheimera",
"lindsay",
"lindy",
"line",
"lineage",
"lineament",
"linearity",
"lineation",
"linebacker",
"linecut",
"lineman",
"linemen",
"linen",
"linendraper",
"liner",
"linesman",
"lineup",
"ling",
"lingam",
"lingberry",
"lingcod",
"lingenberry",
"lingerer",
"lingerie",
"lingering",
"lingo",
"lingonberry",
"lingua",
"lingual",
"lingualumina",
"linguica",
"linguine",
"linguini",
"linguist",
"linguistics",
"liniment",
"linin",
"lining",
"link",
"linkage",
"linkboy",
"linkman",
"links",
"linksman",
"linkup",
"linnaea",
"linnaeus",
"linnet",
"lino",
"linocut",
"linoleum",
"linotype",
"linseed",
"linstock",
"lint",
"lintel",
"lintwhite",
"linum",
"linuron",
"linux",
"linz",
"liomys",
"lion",
"lioness",
"lionet",
"lionfish",
"liopelma",
"liopelmidae",
"liothyronine",
"lipaemia",
"liparidae",
"liparididae",
"liparis",
"lipase",
"lipchitz",
"lipectomy",
"lipemia",
"lipfern",
"lipid",
"lipidaemia",
"lipide",
"lipidemia",
"lipidosis",
"lipitor",
"lipizzan",
"lipmann",
"lipogram",
"lipoid",
"lipoidaemia",
"lipoidemia",
"lipoma",
"lipomatosis",
"lipoprotein",
"liposarcoma",
"liposcelis",
"liposome",
"liposuction",
"lipotyphla",
"lippi",
"lippizan",
"lippizaner",
"lippmann",
"lipreading",
"lipscomb",
"lipstick",
"liquaemin",
"liquefaction",
"liqueur",
"liquid",
"liquidambar",
"liquidation",
"liquidator",
"liquidiser",
"liquidity",
"liquidizer",
"liquidness",
"liquor",
"liquorice",
"lira",
"liriodendron",
"liriope",
"lisboa",
"lisbon",
"lisinopril",
"lisle",
"lisp",
"lisper",
"lissomeness",
"list",
"listener",
"listening",
"lister",
"listera",
"listeria",
"listeriosis",
"listing",
"listlessness",
"liston",
"lisu",
"liszt",
"litany",
"litas",
"litchee",
"litchi",
"liter",
"literacy",
"literal",
"literalism",
"literalness",
"literate",
"literati",
"literature",
"lithane",
"litheness",
"lithiasis",
"lithium",
"lithocarpus",
"lithodidae",
"lithoglyptics",
"lithograph",
"lithographer",
"lithography",
"lithology",
"lithomancer",
"lithomancy",
"lithonate",
"lithophragma",
"lithophyte",
"lithops",
"lithospermum",
"lithosphere",
"lithotomy",
"lithuania",
"lithuanian",
"lithuresis",
"litigant",
"litigation",
"litigator",
"litigiousness",
"litmus",
"litocranius",
"litoral",
"litotes",
"litre",
"litter",
"litterateur",
"litterbin",
"litterbug",
"litterer",
"little",
"littleneck",
"littleness",
"littoral",
"littorina",
"littorinidae",
"littre",
"liturgics",
"liturgiology",
"liturgist",
"liturgy",
"livedo",
"livelihood",
"liveliness",
"livelong",
"liveness",
"liver",
"liverleaf",
"livermore",
"liverpool",
"liverpudlian",
"liverwort",
"liverwurst",
"livery",
"liveryman",
"livestock",
"lividity",
"lividness",
"living",
"livingston",
"livingstone",
"livistona",
"livonia",
"livonian",
"livy",
"liza",
"lizard",
"lizardfish",
"ljubljana",
"llama",
"llano",
"lloyd",
"llud",
"llullaillaco",
"llyr",
"loach",
"load",
"loader",
"loading",
"loads",
"loadstar",
"loadstone",
"loaf",
"loafer",
"loafing",
"loam",
"loan",
"loanblend",
"loaner",
"loaning",
"loanword",
"loasa",
"loasaceae",
"loather",
"loathing",
"loathsomeness",
"lobachevsky",
"lobata",
"lobby",
"lobbyism",
"lobbyist",
"lobe",
"lobectomy",
"lobefin",
"lobelia",
"lobeliaceae",
"lobipes",
"lobito",
"loblolly",
"lobotes",
"lobotidae",
"lobotomy",
"lobscouse",
"lobscuse",
"lobster",
"lobsterback",
"lobsterman",
"lobularia",
"lobularity",
"lobule",
"lobworm",
"local",
"locale",
"localisation",
"localism",
"locality",
"localization",
"locater",
"locating",
"location",
"locative",
"locator",
"loch",
"lochia",
"lock",
"lockage",
"lockbox",
"lockdown",
"locke",
"locker",
"locket",
"locking",
"lockjaw",
"lockkeeper",
"lockman",
"lockmaster",
"locknut",
"lockout",
"lockring",
"locksmith",
"lockstep",
"lockstitch",
"lockup",
"locoism",
"locomotion",
"locomotive",
"locoweed",
"locule",
"loculus",
"locum",
"locus",
"locust",
"locusta",
"locustidae",
"locution",
"lode",
"lodestar",
"lodestone",
"lodge",
"lodgement",
"lodgepole",
"lodger",
"lodging",
"lodgings",
"lodgment",
"lodine",
"lodz",
"loeb",
"loess",
"loestrin",
"loewe",
"loewi",
"lofortyx",
"lofoten",
"loft",
"loftiness",
"logagraphia",
"logan",
"loganberry",
"logania",
"loganiaceae",
"logarithm",
"logbook",
"loge",
"logger",
"loggerhead",
"loggia",
"logginess",
"logging",
"logic",
"logicality",
"logicalness",
"logician",
"logicism",
"loginess",
"logion",
"logistician",
"logistics",
"logjam",
"logo",
"logogram",
"logograph",
"logomach",
"logomachist",
"logomachy",
"logomania",
"logorrhea",
"logos",
"logotype",
"logrolling",
"logrono",
"logwood",
"lohan",
"loin",
"loincloth",
"loins",
"loir",
"loire",
"loiseleuria",
"loiterer",
"loki",
"loligo",
"lolita",
"lolium",
"lollipop",
"lolly",
"lolo",
"loloish",
"lomatia",
"lombard",
"lombardia",
"lombardy",
"lome",
"loment",
"lomogramma",
"lomotil",
"lomustine",
"lonas",
"lonchocarpus",
"london",
"londoner",
"loneliness",
"loner",
"lonesomeness",
"longan",
"longanberry",
"longanimity",
"longbeard",
"longboat",
"longbow",
"longbowman",
"longer",
"longevity",
"longfellow",
"longhand",
"longhorn",
"longicorn",
"longing",
"longitude",
"longlegs",
"longness",
"longroot",
"longshoreman",
"longshot",
"longsightedness",
"longueur",
"longways",
"longwool",
"longyi",
"lonicera",
"loniten",
"lontar",
"loofa",
"loofah",
"look",
"lookdown",
"looker",
"looking",
"lookout",
"lookup",
"loom",
"loon",
"looney",
"loonie",
"loony",
"loop",
"looper",
"loophole",
"looping",
"loos",
"looseness",
"loosening",
"loosestrife",
"loot",
"looter",
"looting",
"lope",
"lophiidae",
"lophius",
"lophodytes",
"lopholatilus",
"lophophora",
"lophophorus",
"lophosoria",
"lophosoriaceae",
"lopid",
"lopper",
"lopressor",
"lopsidedness",
"loquaciousness",
"loquacity",
"loquat",
"loranthaceae",
"loranthus",
"lorazepam",
"lorca",
"lorchel",
"lord",
"lordliness",
"lordolatry",
"lordosis",
"lordship",
"lore",
"lorelei",
"loren",
"lorentz",
"lorenz",
"lorfan",
"lorgnette",
"lorica",
"loricata",
"loriinae",
"lorikeet",
"lorisidae",
"lorraine",
"lorre",
"lorry",
"lory",
"loser",
"losings",
"loss",
"losses",
"lost",
"lota",
"lothario",
"lothringen",
"loti",
"lotion",
"lots",
"lotte",
"lottery",
"lotto",
"lotus",
"lotusland",
"loudmouth",
"loudness",
"loudspeaker",
"lough",
"louis",
"louisiana",
"louisianan",
"louisianian",
"louisville",
"lounge",
"lounger",
"loungewear",
"loupe",
"louse",
"lousiness",
"lout",
"louvar",
"louver",
"louvre",
"lovage",
"lovastatin",
"love",
"lovebird",
"lovelace",
"loveliness",
"lovell",
"lovely",
"lovemaking",
"lover",
"loveseat",
"lovesickness",
"lovingness",
"lovoa",
"lowan",
"lowboy",
"lowbrow",
"lowell",
"lower",
"lowercase",
"lowerclassman",
"lowering",
"lowland",
"lowlander",
"lowlands",
"lowlife",
"lowliness",
"lowness",
"lowry",
"loxapine",
"loxia",
"loxitane",
"loxodonta",
"loxodrome",
"loxoma",
"loxomataceae",
"loxostege",
"loyalist",
"loyalty",
"loyang",
"loyola",
"lozal",
"lozenge",
"lozier",
"ltte",
"luanda",
"luau",
"luba",
"lubavitch",
"lubavitcher",
"lubber",
"lubbock",
"lube",
"lubeck",
"lubitsch",
"lublin",
"lubricant",
"lubrication",
"lubricator",
"lubricity",
"lubumbashi",
"lucania",
"lucanidae",
"lucas",
"luce",
"lucerne",
"lucidity",
"lucidness",
"lucifer",
"luciferin",
"lucilia",
"lucite",
"luck",
"luckiness",
"lucknow",
"lucrativeness",
"lucre",
"lucretius",
"lucubration",
"lucullus",
"luculus",
"lucy",
"luda",
"luddite",
"ludian",
"ludo",
"lues",
"lufengpithecus",
"luff",
"luffa",
"lufkin",
"luftwaffe",
"luganda",
"luge",
"luger",
"luggage",
"lugger",
"lugh",
"luging",
"lugosi",
"lugsail",
"lugubriousness",
"lugworm",
"luik",
"luke",
"lukewarmness",
"lull",
"lullaby",
"lulli",
"lully",
"lulu",
"luluabourg",
"lumbago",
"lumber",
"lumbering",
"lumberjack",
"lumberman",
"lumbermill",
"lumberyard",
"lumbus",
"lumen",
"luminal",
"luminance",
"luminary",
"luminescence",
"luminism",
"luminosity",
"luminousness",
"lumma",
"lummox",
"lump",
"lumpectomy",
"lumpenus",
"lumper",
"lumpfish",
"lumpsucker",
"luna",
"lunacy",
"lunaria",
"lunatic",
"lunation",
"lunch",
"luncheon",
"luncher",
"lunching",
"lunchroom",
"lunchtime",
"lund",
"lunda",
"lunette",
"lung",
"lunge",
"lungen",
"lunger",
"lungfish",
"lungi",
"lungyi",
"lunkhead",
"lunt",
"lunula",
"lunule",
"luoyang",
"lupin",
"lupine",
"lupinus",
"lupus",
"lurch",
"lurcher",
"lure",
"luridness",
"lurker",
"lusaka",
"lusatian",
"luscinia",
"lusciousness",
"lush",
"lushness",
"lushun",
"lusitania",
"lust",
"luster",
"lusterlessness",
"lusterware",
"lustfulness",
"lustiness",
"lustre",
"lustrelessness",
"lustrum",
"luta",
"lutanist",
"lute",
"lutecium",
"lutefisk",
"lutein",
"lutenist",
"luteotropin",
"lutetium",
"lutfisk",
"luther",
"lutheran",
"lutheranism",
"luthier",
"luting",
"lutist",
"lutjanidae",
"lutjanus",
"lutra",
"lutrinae",
"lutyens",
"lutzen",
"luvaridae",
"luvarus",
"luvian",
"luwian",
"luxation",
"luxembourg",
"luxembourger",
"luxemburg",
"luxemburger",
"luxor",
"luxuria",
"luxuriance",
"luxuriation",
"luxuriousness",
"luxury",
"luyia",
"luzon",
"lwei",
"lxxviii",
"lxxx",
"lyallpur",
"lycaena",
"lycaenid",
"lycaenidae",
"lycaeon",
"lycanthrope",
"lycanthropy",
"lycee",
"lyceum",
"lychee",
"lychgate",
"lychnis",
"lycia",
"lycian",
"lycium",
"lycopene",
"lycoperdaceae",
"lycoperdales",
"lycoperdon",
"lycopersicon",
"lycopersicum",
"lycophyta",
"lycopod",
"lycopodiaceae",
"lycopodiales",
"lycopodiate",
"lycopodineae",
"lycopodium",
"lycopsida",
"lycopus",
"lycosa",
"lycosidae",
"lydia",
"lydian",
"lygaeid",
"lygaeidae",
"lyginopteris",
"lygodium",
"lygus",
"lying",
"lyly",
"lymantria",
"lymantriid",
"lymantriidae",
"lymph",
"lymphadenitis",
"lymphadenoma",
"lymphadenopathy",
"lymphangiogram",
"lymphangioma",
"lymphangitis",
"lymphedema",
"lymphoblast",
"lymphocyte",
"lymphocytopenia",
"lymphocytosis",
"lymphogranuloma",
"lymphography",
"lymphokine",
"lymphoma",
"lymphopenia",
"lymphopoiesis",
"lymphuria",
"lynchburg",
"lynching",
"lynchpin",
"lynx",
"lyon",
"lyonia",
"lyonnais",
"lyons",
"lyophilisation",
"lyophilization",
"lypressin",
"lyra",
"lyre",
"lyrebird",
"lyreflower",
"lyric",
"lyricality",
"lyricism",
"lyricist",
"lyrist",
"lyrurus",
"lysander",
"lysenko",
"lysichiton",
"lysichitum",
"lysiloma",
"lysimachia",
"lysimachus",
"lysin",
"lysine",
"lysinemia",
"lysippus",
"lysis",
"lysogenicity",
"lysogenisation",
"lysogenization",
"lysogeny",
"lysol",
"lysosome",
"lysozyme",
"lyssa",
"lyssavirus",
"lythraceae",
"lythrum",
"lytton",
"maalox",
"maar",
"maarianhamina",
"macaca",
"macadam",
"macadamia",
"macamba",
"macao",
"macaque",
"macaroni",
"macaroon",
"macarthur",
"macau",
"macaulay",
"macaw",
"macbeth",
"macdowell",
"mace",
"macebearer",
"macedoine",
"macedon",
"macedonia",
"macedonian",
"macer",
"maceration",
"macgregor",
"macguffin",
"mach",
"machaeranthera",
"machete",
"machiavelli",
"machiavellian",
"machicolation",
"machilid",
"machilidae",
"machination",
"machinator",
"machine",
"machinery",
"machinist",
"machismo",
"machmeter",
"macho",
"macintosh",
"mack",
"mackem",
"mackenzie",
"mackerel",
"mackinaw",
"mackintosh",
"mackle",
"macleaya",
"macleish",
"macleod",
"maclura",
"macon",
"maconnais",
"macoun",
"macowanites",
"macrame",
"macrencephaly",
"macro",
"macrobiotics",
"macrocephalon",
"macrocephaly",
"macrocheira",
"macroclemys",
"macrocosm",
"macrocyte",
"macrocytosis",
"macrodactylus",
"macrodantin",
"macroeconomics",
"macroeconomist",
"macroevolution",
"macroglia",
"macroglossia",
"macromolecule",
"macron",
"macronectes",
"macrophage",
"macropodidae",
"macropus",
"macrosporangium",
"macrospore",
"macrotis",
"macrotus",
"macrotyloma",
"macrouridae",
"macrozamia",
"macrozoarces",
"macruridae",
"macula",
"maculation",
"macule",
"macumba",
"macushla",
"madagascan",
"madagascar",
"madake",
"madam",
"madame",
"madcap",
"madder",
"madderwort",
"madeira",
"madeiras",
"mademoiselle",
"madhouse",
"madia",
"madison",
"madman",
"madnep",
"madness",
"madonna",
"madoqua",
"madras",
"madrasa",
"madrasah",
"madreporaria",
"madrepore",
"madrid",
"madrigal",
"madrigalist",
"madrilene",
"madrona",
"madrono",
"madwoman",
"madwort",
"maeandra",
"maelstrom",
"maenad",
"maestro",
"maeterlinck",
"mafa",
"maffia",
"mafia",
"mafioso",
"magadhan",
"magazine",
"magdalen",
"magdalena",
"magellan",
"magenta",
"maggot",
"magh",
"magha",
"maghreb",
"magi",
"magic",
"magician",
"magicicada",
"magilp",
"maginot",
"magistracy",
"magistrate",
"magistrature",
"maglev",
"magma",
"magnanimity",
"magnanimousness",
"magnate",
"magnesia",
"magnesite",
"magnesium",
"magnet",
"magnetics",
"magnetisation",
"magnetism",
"magnetite",
"magnetization",
"magneto",
"magnetograph",
"magnetometer",
"magneton",
"magnetosphere",
"magnetron",
"magnificat",
"magnification",
"magnificence",
"magnifico",
"magnifier",
"magniloquence",
"magnitude",
"magnolia",
"magnoliaceae",
"magnoliidae",
"magnoliophyta",
"magnoliopsid",
"magnoliopsida",
"magnum",
"magpie",
"magritte",
"maguey",
"magus",
"magyar",
"magyarorszag",
"maha",
"mahabharata",
"mahabharatam",
"mahabharatum",
"mahagua",
"mahan",
"maharaja",
"maharajah",
"maharanee",
"maharani",
"maharashtra",
"mahatma",
"mahayana",
"mahayanism",
"mahayanist",
"mahdi",
"mahdism",
"mahdist",
"mahgrib",
"mahican",
"mahimahi",
"mahjong",
"mahler",
"mahlstick",
"mahoe",
"mahogany",
"mahomet",
"mahonia",
"mahound",
"mahout",
"mahratta",
"mahratti",
"mahuang",
"maia",
"maianthemum",
"maid",
"maiden",
"maidenhair",
"maidenhead",
"maidenhood",
"maidenliness",
"maidhood",
"maidism",
"maidservant",
"maidu",
"maiduguri",
"maiger",
"maigre",
"maikoa",
"mail",
"mailbag",
"mailboat",
"mailbox",
"maildrop",
"mailer",
"mailing",
"maillol",
"maillot",
"mailman",
"mailsorter",
"maimed",
"maimer",
"maimonides",
"main",
"maine",
"mainer",
"mainframe",
"mainland",
"mainmast",
"mainsail",
"mainsheet",
"mainspring",
"mainstay",
"mainstream",
"maintainer",
"maintenance",
"maintenon",
"maiolica",
"maisonette",
"maisonnette",
"maitland",
"maitreya",
"maize",
"maja",
"majagua",
"majesty",
"majidae",
"majolica",
"major",
"majorana",
"majorca",
"majorette",
"majority",
"majors",
"majuscule",
"makaira",
"makalu",
"make",
"makedonija",
"makeover",
"maker",
"makeready",
"makeshift",
"makeup",
"makeweight",
"makin",
"making",
"mako",
"makomako",
"malabo",
"malabsorption",
"malacanthidae",
"malacca",
"malachi",
"malachias",
"malachite",
"malacia",
"malaclemys",
"malacologist",
"malacology",
"malaconotinae",
"malacopterygian",
"malacopterygii",
"malacosoma",
"malacostraca",
"malacothamnus",
"maladjustment",
"maladroitness",
"malady",
"malaga",
"malahini",
"malaise",
"malamud",
"malamute",
"malanga",
"malaprop",
"malapropism",
"malar",
"malaria",
"malarkey",
"malarky",
"malathion",
"malawi",
"malawian",
"malaxis",
"malay",
"malaya",
"malayalam",
"malayan",
"malaysia",
"malaysian",
"malcolmia",
"malcontent",
"maldivan",
"maldives",
"maldivian",
"maldon",
"male",
"maleate",
"maleberry",
"malebranche",
"malecite",
"malediction",
"malefactor",
"maleficence",
"malemute",
"maleness",
"maleo",
"maleseet",
"malevich",
"malevolence",
"malevolency",
"malfeasance",
"malfeasant",
"malformation",
"malfunction",
"mali",
"malian",
"malice",
"maliciousness",
"malignance",
"malignancy",
"maligner",
"malignity",
"malignment",
"malik",
"malingerer",
"malingering",
"malinois",
"malinowski",
"mall",
"mallard",
"mallarme",
"malleability",
"mallee",
"mallet",
"malleus",
"mallon",
"mallophaga",
"mallotus",
"mallow",
"malmo",
"malmsey",
"malnourishment",
"malnutrition",
"malocclusion",
"malodor",
"malodorousness",
"malodour",
"malone",
"malonylurea",
"malope",
"malopterurus",
"malory",
"malosma",
"malpighi",
"malpighia",
"malpighiaceae",
"malposition",
"malpractice",
"malraux",
"mals",
"malt",
"malta",
"malted",
"maltese",
"maltha",
"malthus",
"malthusian",
"malthusianism",
"malti",
"maltman",
"malto",
"maltose",
"maltreater",
"maltreatment",
"maltster",
"malus",
"malva",
"malvaceae",
"malvales",
"malvasia",
"malvastrum",
"malvaviscus",
"malversation",
"malware",
"mama",
"mamba",
"mambo",
"mamet",
"mamey",
"mamilla",
"mamma",
"mammal",
"mammalia",
"mammalian",
"mammalogist",
"mammalogy",
"mammea",
"mammee",
"mammilla",
"mammillaria",
"mammogram",
"mammography",
"mammon",
"mammoth",
"mammut",
"mammuthus",
"mammutidae",
"mammy",
"mamo",
"mamoncillo",
"manacle",
"manageability",
"manageableness",
"management",
"manager",
"manageress",
"managership",
"managua",
"manakin",
"manama",
"manana",
"manannan",
"manat",
"manatee",
"manawydan",
"manawyddan",
"manchester",
"manchu",
"manchuria",
"mancunian",
"manda",
"mandaean",
"mandaeanism",
"mandala",
"mandalay",
"mandamus",
"mandara",
"mandarin",
"mandatary",
"mandate",
"mandator",
"mandatory",
"mande",
"mandean",
"mandeanism",
"mandela",
"mandelamine",
"mandelbrot",
"mandelshtam",
"mandelstam",
"mandevilla",
"mandible",
"mandibula",
"mandioc",
"mandioca",
"mandola",
"mandolin",
"mandragora",
"mandrake",
"mandrel",
"mandril",
"mandrill",
"mandrillus",
"manduca",
"manduction",
"mane",
"manes",
"manet",
"maneuver",
"maneuverability",
"maneuverer",
"manfulness",
"manga",
"mangabey",
"manganate",
"manganese",
"manganite",
"mange",
"manger",
"mangifera",
"manginess",
"mangle",
"mangler",
"manglietia",
"mango",
"mangold",
"mangonel",
"mangosteen",
"mangrove",
"manhattan",
"manhole",
"manhood",
"manhunt",
"mania",
"maniac",
"manichaean",
"manichaeanism",
"manichaeism",
"manichean",
"manichee",
"manicotti",
"manicure",
"manicurist",
"manidae",
"manifest",
"manifestation",
"manifesto",
"manifold",
"manihot",
"manikin",
"manila",
"manilkara",
"manilla",
"manioc",
"manioca",
"manipulability",
"manipulation",
"manipulator",
"manipur",
"maniraptor",
"maniraptora",
"manis",
"manitoba",
"mankato",
"mankind",
"manliness",
"mann",
"manna",
"mannequin",
"manner",
"mannerism",
"manners",
"mannheim",
"mannikin",
"mannitol",
"manoeuvrability",
"manoeuvre",
"manoeuvrer",
"manometer",
"manor",
"manpad",
"manpower",
"manroot",
"mansard",
"mansart",
"manse",
"manservant",
"mansfield",
"mansi",
"mansion",
"manslaughter",
"manslayer",
"manson",
"manta",
"mantegna",
"manteidae",
"mantel",
"mantelet",
"mantell",
"mantelpiece",
"manteodea",
"mantichora",
"manticora",
"manticore",
"mantid",
"mantidae",
"mantiger",
"mantilla",
"mantinea",
"mantineia",
"mantis",
"mantispid",
"mantispidae",
"mantissa",
"mantle",
"mantlepiece",
"mantlet",
"mantra",
"mantrap",
"mantua",
"manual",
"manubrium",
"manufactory",
"manufacture",
"manufacturer",
"manufacturing",
"manul",
"manumission",
"manumitter",
"manure",
"manus",
"manuscript",
"manx",
"manzanilla",
"manzanita",
"manzoni",
"maoi",
"maoism",
"maoist",
"maori",
"mapinguari",
"maple",
"mapmaking",
"mapper",
"mapping",
"mapquest",
"maputo",
"maquiladora",
"maquis",
"maquisard",
"mara",
"marabou",
"marabout",
"maraca",
"maracaibo",
"maracay",
"maraco",
"marang",
"maranta",
"marantaceae",
"marasca",
"maraschino",
"marasmius",
"marasmus",
"marat",
"maratha",
"marathi",
"marathon",
"marathoner",
"marattia",
"marattiaceae",
"marattiales",
"maraud",
"marauder",
"maravilla",
"marble",
"marbleisation",
"marbleising",
"marbleization",
"marbleizing",
"marbles",
"marblewood",
"marbling",
"marc",
"marceau",
"marcel",
"march",
"marchantia",
"marchantiaceae",
"marchantiales",
"marche",
"marcher",
"marches",
"marching",
"marchioness",
"marchland",
"marchpane",
"marciano",
"marcionism",
"marconi",
"marcuse",
"marduk",
"mare",
"marengo",
"margarin",
"margarine",
"margarita",
"margasivsa",
"margate",
"margay",
"marge",
"margin",
"marginalia",
"marginalisation",
"marginality",
"marginalization",
"marginocephalia",
"margosa",
"margrave",
"marguerite",
"mari",
"maria",
"mariachi",
"marianas",
"maricopa",
"mariehamn",
"marigold",
"marihuana",
"marijuana",
"marimba",
"marina",
"marinade",
"marinara",
"marine",
"marineland",
"mariner",
"marines",
"marini",
"marino",
"marionette",
"mariposa",
"mariposan",
"mariticide",
"maritimes",
"marjoram",
"mark",
"marker",
"market",
"marketer",
"marketing",
"marketplace",
"markhoor",
"markhor",
"marking",
"markka",
"markoff",
"markov",
"markova",
"marks",
"marksman",
"marksmanship",
"markup",
"markweed",
"marl",
"marlberry",
"marley",
"marlin",
"marline",
"marlinespike",
"marlingspike",
"marlinspike",
"marlite",
"marlowe",
"marlstone",
"marmalade",
"marmara",
"marmite",
"marmora",
"marmoset",
"marmot",
"marmota",
"maroc",
"marocain",
"maroon",
"marplan",
"marquand",
"marque",
"marquee",
"marquess",
"marqueterie",
"marquetry",
"marquette",
"marquis",
"marquise",
"marrakech",
"marrakesh",
"marrano",
"marri",
"marriage",
"marriageability",
"married",
"marrow",
"marrowbone",
"marrubium",
"marruecos",
"mars",
"marsala",
"marseillaise",
"marseille",
"marseilles",
"marsh",
"marshal",
"marshall",
"marshals",
"marshalship",
"marshland",
"marshmallow",
"marsilea",
"marsileaceae",
"marstan",
"marsupial",
"marsupialia",
"marsupium",
"mart",
"martagon",
"marten",
"martensite",
"martes",
"marti",
"martial",
"martian",
"martin",
"martinet",
"martingale",
"martini",
"martinique",
"martinmas",
"martynia",
"martyniaceae",
"martyr",
"martyrdom",
"marum",
"marumi",
"marupa",
"marut",
"marvel",
"marvell",
"marveller",
"marx",
"marxism",
"marxist",
"mary",
"maryland",
"marylander",
"marzipan",
"masa",
"masai",
"mascara",
"mascarpone",
"mascot",
"masculine",
"masculinisation",
"masculinity",
"masculinization",
"masdevallia",
"masefield",
"maser",
"maseru",
"mash",
"masher",
"mashhad",
"mashi",
"mashie",
"mashriq",
"masjid",
"mask",
"masker",
"masking",
"masochism",
"masochist",
"mason",
"masonite",
"masonry",
"masora",
"masorah",
"masorete",
"masorite",
"masoud",
"masqat",
"masque",
"masquer",
"masquerade",
"masquerader",
"mass",
"massachuset",
"massachusetts",
"massacre",
"massage",
"massager",
"massasauga",
"massasoit",
"massawa",
"masse",
"massenet",
"masses",
"masseter",
"masseur",
"masseuse",
"massicot",
"massicotite",
"massif",
"massine",
"massiveness",
"massorete",
"mast",
"mastaba",
"mastabah",
"mastalgia",
"mastectomy",
"master",
"mastering",
"mastermind",
"masterpiece",
"masters",
"mastership",
"masterstroke",
"masterwort",
"mastery",
"masthead",
"mastic",
"mastication",
"masticophis",
"mastiff",
"mastigomycota",
"mastigomycotina",
"mastigophora",
"mastigophoran",
"mastigophore",
"mastigoproctus",
"mastitis",
"mastocyte",
"mastodon",
"mastodont",
"mastoid",
"mastoidal",
"mastoidale",
"mastoidectomy",
"mastoiditis",
"mastopathy",
"mastopexy",
"mastotermes",
"mastotermitidae",
"masturbation",
"masturbator",
"matabele",
"matador",
"matai",
"matakam",
"matamoros",
"match",
"matchboard",
"matchbook",
"matchbox",
"matchbush",
"matcher",
"matchet",
"matchlock",
"matchmaker",
"matchmaking",
"matchstick",
"matchup",
"matchweed",
"matchwood",
"mate",
"matelote",
"mater",
"materfamilias",
"material",
"materialisation",
"materialism",
"materialist",
"materiality",
"materialization",
"materiel",
"maternalism",
"maternity",
"mates",
"math",
"mathematician",
"mathematics",
"mathias",
"maths",
"matinee",
"mating",
"matins",
"matisse",
"matman",
"matoaka",
"matriarch",
"matriarchate",
"matriarchy",
"matric",
"matricaria",
"matricide",
"matriculate",
"matriculation",
"matrikin",
"matrilineage",
"matrimony",
"matrisib",
"matrix",
"matron",
"matronymic",
"matsyendra",
"matt",
"matte",
"matter",
"matterhorn",
"matteuccia",
"matthew",
"matthiola",
"matting",
"mattock",
"mattole",
"mattress",
"maturation",
"maturement",
"matureness",
"maturity",
"matzah",
"matzo",
"matzoh",
"maugham",
"maui",
"maul",
"mauldin",
"mauler",
"maulers",
"maulstick",
"maund",
"maundy",
"maupassant",
"mauriac",
"mauritania",
"mauritanian",
"mauritanie",
"mauritian",
"mauritius",
"maurois",
"mauser",
"mausoleum",
"mauve",
"maven",
"maverick",
"mavik",
"mavin",
"mavis",
"mawkishness",
"mawlamyine",
"maxi",
"maxilla",
"maxillaria",
"maxillary",
"maxim",
"maximation",
"maximian",
"maximisation",
"maximization",
"maximum",
"maxostoma",
"maxwell",
"maxzide",
"maya",
"mayaca",
"mayacaceae",
"mayakovski",
"mayan",
"mayapple",
"mayday",
"mayeng",
"mayenne",
"mayer",
"mayetiola",
"mayfish",
"mayflower",
"mayfly",
"mayhaw",
"mayhem",
"mayidism",
"mayo",
"mayonnaise",
"mayor",
"mayoralty",
"mayoress",
"maypole",
"maypop",
"mays",
"mayweed",
"mazama",
"mazatlan",
"mazdaism",
"maze",
"mazer",
"mazopathy",
"mazurka",
"mazzard",
"mazzini",
"mbabane",
"mbeya",
"mbit",
"mbundu",
"mcalester",
"mcallen",
"mccarthy",
"mccarthyism",
"mccartney",
"mccauley",
"mccormick",
"mccullers",
"mcgraw",
"mcguffey",
"mcguffin",
"mcia",
"mcintosh",
"mckim",
"mckinley",
"mcluhan",
"mcmaster",
"mcpherson",
"mdiv",
"mdma",
"mead",
"meade",
"meadow",
"meadowgrass",
"meadowlark",
"meagerness",
"meagreness",
"meal",
"mealberry",
"mealie",
"mealtime",
"mealworm",
"mealybug",
"mean",
"meander",
"meanie",
"meaning",
"meaningfulness",
"meaninglessness",
"meanness",
"means",
"meantime",
"meanwhile",
"meany",
"mearstone",
"measles",
"measurability",
"measure",
"measurement",
"measurer",
"measuring",
"meat",
"meatball",
"meatloaf",
"meatman",
"meatpacking",
"meatus",
"mebaral",
"mebendazole",
"mebibit",
"mebibyte",
"mecca",
"meccano",
"mechanic",
"mechanics",
"mechanisation",
"mechanism",
"mechanist",
"mechanization",
"mecholyl",
"meclizine",
"meclofenamate",
"meclomen",
"meconium",
"meconopsis",
"mecoptera",
"mecopteran",
"medal",
"medalist",
"medallion",
"medallist",
"medan",
"medawar",
"meddler",
"meddlesomeness",
"meddling",
"medea",
"medellin",
"medevac",
"medfly",
"medford",
"mediacy",
"median",
"mediant",
"mediastinum",
"mediateness",
"mediation",
"mediator",
"mediatrix",
"medic",
"medicago",
"medicaid",
"medical",
"medicament",
"medicare",
"medication",
"medici",
"medicine",
"medick",
"medico",
"mediety",
"medina",
"medinilla",
"mediocrity",
"meditation",
"meditativeness",
"mediterranean",
"medium",
"medivac",
"medlar",
"medlars",
"medley",
"medline",
"medoc",
"medulla",
"medusa",
"medusan",
"medusoid",
"meed",
"meekness",
"meerestone",
"meerkat",
"meerschaum",
"meet",
"meeter",
"meeting",
"meetinghouse",
"mefloquine",
"mefoxin",
"megabat",
"megabit",
"megabucks",
"megabyte",
"megacardia",
"megacephaly",
"megachile",
"megachilidae",
"megachiroptera",
"megacolon",
"megacycle",
"megadeath",
"megaderma",
"megadermatidae",
"megaera",
"megaflop",
"megagametophyte",
"megahertz",
"megahit",
"megakaryocyte",
"megalith",
"megalobatrachus",
"megaloblast",
"megalocardia",
"megalocephaly",
"megalocyte",
"megalohepatia",
"megalomania",
"megalomaniac",
"megalonychidae",
"megalopolis",
"megaloptera",
"megalosaur",
"megalosauridae",
"megalosaurus",
"megaphone",
"megapode",
"megapodiidae",
"megapodius",
"megaptera",
"megasporangium",
"megaspore",
"megasporophyll",
"megathere",
"megatherian",
"megatheriid",
"megatheriidae",
"megatherium",
"megaton",
"megawatt",
"megestrol",
"megillah",
"megilp",
"megohm",
"megrim",
"megrims",
"meiosis",
"meir",
"meissner",
"meitner",
"meitnerium",
"mekong",
"melaena",
"melagra",
"melamine",
"melampodium",
"melampsora",
"melampsoraceae",
"melancholia",
"melancholiac",
"melancholic",
"melancholy",
"melanchthon",
"melanerpes",
"melanesia",
"melange",
"melanin",
"melanism",
"melanitta",
"melanoblast",
"melanocyte",
"melanoderma",
"melanogrammus",
"melanoma",
"melanoplus",
"melanosis",
"melanotis",
"melanthiaceae",
"melasma",
"melastoma",
"melastomaceae",
"melastomataceae",
"melatonin",
"melba",
"melbourne",
"melchior",
"melchite",
"meld",
"meleagrididae",
"meleagris",
"melee",
"melena",
"meles",
"melia",
"meliaceae",
"melicocca",
"melicoccus",
"melicytus",
"melilot",
"melilotus",
"melinae",
"melioration",
"meliorism",
"meliorist",
"meliphagidae",
"melissa",
"melkite",
"mellaril",
"mellivora",
"mellon",
"mellowing",
"mellowness",
"melocactus",
"melodiousness",
"melodrama",
"melody",
"melogale",
"meloid",
"meloidae",
"melolontha",
"melolonthidae",
"melon",
"melophagus",
"melopsittacus",
"melosa",
"melospiza",
"melphalan",
"melpomene",
"melt",
"meltdown",
"melter",
"melting",
"meltwater",
"melursus",
"melville",
"member",
"membership",
"membracidae",
"membrane",
"membranophone",
"meme",
"memel",
"memento",
"memo",
"memoir",
"memorabilia",
"memorability",
"memoranda",
"memorandum",
"memorial",
"memorialisation",
"memorialization",
"memorisation",
"memoriser",
"memorization",
"memorizer",
"memory",
"memphis",
"memsahib",
"menace",
"menadione",
"menage",
"menagerie",
"menander",
"menarche",
"mencken",
"mend",
"mendacity",
"mendel",
"mendeleev",
"mendelevium",
"mendeleyev",
"mendelian",
"mendelianism",
"mendelism",
"mendelsohn",
"mendelssohn",
"mender",
"mendicancy",
"mendicant",
"mendicity",
"mending",
"menelaus",
"menhaden",
"menhir",
"menial",
"meniere",
"meninges",
"meningioma",
"meningism",
"meningitis",
"meningocele",
"meninx",
"menippe",
"meniscectomy",
"meniscium",
"meniscus",
"menispermaceae",
"menispermum",
"menninger",
"mennonite",
"mennonitism",
"menominee",
"menomini",
"menopause",
"menopon",
"menorah",
"menorrhagia",
"menorrhea",
"menotti",
"menotyphla",
"mensa",
"mensch",
"menses",
"mensh",
"menshevik",
"menstruation",
"menstruum",
"mensuration",
"mentalism",
"mentality",
"mentation",
"mentha",
"menthol",
"menticirrhus",
"mention",
"mentioner",
"mentor",
"mentum",
"mentzelia",
"menu",
"menuhin",
"menura",
"menurae",
"menuridae",
"menyanthaceae",
"menyanthes",
"menziesia",
"meow",
"mepacrine",
"meperidine",
"mephaquine",
"mephenytoin",
"mephistopheles",
"mephitinae",
"mephitis",
"mephobarbital",
"meprin",
"meprobamate",
"meralgia",
"merbromine",
"mercantilism",
"mercaptopurine",
"mercator",
"mercedario",
"mercenaria",
"mercenary",
"mercer",
"merchandise",
"merchandiser",
"merchandising",
"merchant",
"merchantability",
"merchantman",
"mercifulness",
"mercilessness",
"merckx",
"mercouri",
"mercurialis",
"mercurochrome",
"mercury",
"mercy",
"mere",
"meredith",
"merestone",
"merganser",
"mergenthaler",
"merger",
"merginae",
"merging",
"mergus",
"mericarp",
"merida",
"meridian",
"meringue",
"merino",
"meriones",
"meristem",
"merit",
"meritocracy",
"meritoriousness",
"merl",
"merlangus",
"merle",
"merlin",
"merlon",
"merlot",
"merluccius",
"mermaid",
"merman",
"merodach",
"meromelia",
"meronym",
"meronymy",
"meropidae",
"merops",
"merostomata",
"merovingian",
"merozoite",
"merrimac",
"merrimack",
"merriment",
"merriness",
"merrymaker",
"merrymaking",
"mertensia",
"merthiolate",
"merton",
"meryta",
"mesa",
"mesalliance",
"mesantoin",
"mesasamkranti",
"mescal",
"mescaline",
"mesencephalon",
"mesenchyme",
"mesentery",
"mesh",
"meshed",
"meshing",
"meshugaas",
"meshuggeneh",
"meshuggener",
"meshwork",
"mesmer",
"mesmerism",
"mesmerist",
"mesmerizer",
"mesoamerica",
"mesoamerican",
"mesoblast",
"mesocarp",
"mesocolon",
"mesocricetus",
"mesoderm",
"mesohippus",
"mesolithic",
"mesomorph",
"mesomorphy",
"meson",
"mesophyron",
"mesophyte",
"mesopotamia",
"mesosphere",
"mesothelioma",
"mesothelium",
"mesotron",
"mesozoic",
"mespilus",
"mesquit",
"mesquite",
"mess",
"message",
"messaging",
"messenger",
"messiah",
"messiahship",
"messidor",
"messina",
"messiness",
"messmate",
"messuage",
"mestiza",
"mestizo",
"mestranol",
"mesua",
"metabola",
"metabolism",
"metabolite",
"metacarpal",
"metacarpus",
"metacenter",
"metacentre",
"metacyesis",
"metadata",
"metagenesis",
"metaknowledge",
"metal",
"metalanguage",
"metalepsis",
"metalhead",
"metallic",
"metallurgist",
"metallurgy",
"metalware",
"metalwork",
"metalworker",
"metalworking",
"metalworks",
"metamathematics",
"metamere",
"metamorphism",
"metamorphopsia",
"metamorphosis",
"metaphase",
"metaphor",
"metaphysics",
"metaphysis",
"metaproterenol",
"metarule",
"metasequoia",
"metastability",
"metastasis",
"metatarsal",
"metatarsus",
"metatheria",
"metatherian",
"metathesis",
"metazoa",
"metazoan",
"metchnikoff",
"metchnikov",
"mete",
"metempsychosis",
"metencephalon",
"meteor",
"meteorite",
"meteoroid",
"meteorologist",
"meteorology",
"meteortropism",
"meter",
"meterstick",
"metformin",
"meth",
"methacholine",
"methadon",
"methadone",
"methamphetamine",
"methanal",
"methane",
"methanogen",
"methanol",
"methapyrilene",
"methaqualone",
"metharbital",
"methedrine",
"metheglin",
"methenamine",
"methicillin",
"methionine",
"methocarbamol",
"method",
"methodicalness",
"methodism",
"methodist",
"methodists",
"methodology",
"methotrexate",
"methuselah",
"methyl",
"methylbenzene",
"methyldopa",
"methylene",
"methylphenidate",
"metic",
"metical",
"meticorten",
"meticulosity",
"meticulousness",
"metier",
"metis",
"metonym",
"metonymy",
"metopion",
"metoprolol",
"metralgia",
"metrazol",
"metre",
"metrestick",
"metric",
"metrication",
"metrics",
"metrification",
"metritis",
"metro",
"metrology",
"metronidazole",
"metronome",
"metronymic",
"metropolis",
"metropolitan",
"metroptosis",
"metrorrhagia",
"metroxylon",
"metternich",
"mettle",
"mettlesomeness",
"metycaine",
"meuse",
"mevacor",
"mews",
"mexicali",
"mexican",
"mexicano",
"mexico",
"mexiletine",
"mexitil",
"meyerbeer",
"meyerhof",
"mezcal",
"mezereon",
"mezereum",
"mezuza",
"mezuzah",
"mezzanine",
"mezzo",
"mezzotint",
"mflop",
"miami",
"miao",
"miaou",
"miaow",
"miasm",
"miasma",
"miaul",
"mibit",
"mica",
"micah",
"micawber",
"micelle",
"michael",
"michaelmas",
"michaelmastide",
"micheas",
"michelangelo",
"michelson",
"michener",
"michigan",
"michigander",
"mick",
"mickey",
"mickle",
"micmac",
"miconazole",
"microbalance",
"microbar",
"microbat",
"microbe",
"microbiologist",
"microbiology",
"microbrachia",
"microbrewery",
"microcentrum",
"microcephalus",
"microcephaly",
"microchip",
"microchiroptera",
"microcircuit",
"micrococcaceae",
"micrococcus",
"microcode",
"microcomputer",
"microcosm",
"microcyte",
"microcytosis",
"microdesmidae",
"microdipodops",
"microdot",
"microeconomics",
"microeconomist",
"microevolution",
"microfarad",
"microfiche",
"microfilm",
"microflora",
"microfossil",
"microgauss",
"microglia",
"microgliacyte",
"microgram",
"microgramma",
"microhylidae",
"micromeria",
"micrometeor",
"micrometeorite",
"micrometeoroid",
"micrometer",
"micrometry",
"micromicron",
"micromillimeter",
"micromillimetre",
"micromyx",
"micron",
"micronase",
"micronesia",
"micronor",
"micronutrient",
"microorganism",
"micropenis",
"microphage",
"microphallus",
"microphone",
"microphoning",
"microphotometer",
"micropogonias",
"microprocessor",
"micropterus",
"micropyle",
"microradian",
"microscope",
"microscopist",
"microscopium",
"microscopy",
"microsecond",
"microseism",
"microsome",
"microsorium",
"microsporangium",
"microspore",
"microsporidian",
"microsporophyll",
"microsporum",
"microstomus",
"microstrobos",
"microsurgery",
"microtaggant",
"microtome",
"microtubule",
"microtus",
"microvolt",
"microwave",
"microzide",
"micruroides",
"micrurus",
"micturition",
"midafternoon",
"midair",
"midas",
"midazolam",
"midbrain",
"midday",
"midden",
"middle",
"middlebreaker",
"middlebrow",
"middleman",
"middleton",
"middleweight",
"middling",
"middy",
"mideast",
"midfield",
"midgard",
"midge",
"midget",
"midgrass",
"midi",
"midinette",
"midiron",
"midland",
"midline",
"midnight",
"midplane",
"midpoint",
"midrash",
"midrib",
"midriff",
"midsection",
"midshipman",
"midst",
"midstream",
"midsummer",
"midterm",
"midvein",
"midwatch",
"midway",
"midweek",
"midwest",
"midwife",
"midwifery",
"midwinter",
"mien",
"mierkat",
"mifepristone",
"miff",
"might",
"mightiness",
"mignonette",
"migraine",
"migrant",
"migration",
"migrator",
"mihrab",
"mikado",
"mikania",
"mike",
"mikmaq",
"mikvah",
"milady",
"milage",
"milan",
"milanese",
"milano",
"milcher",
"mildew",
"mildness",
"mile",
"mileage",
"mileometer",
"milepost",
"miler",
"milestone",
"milfoil",
"milhaud",
"miliaria",
"milieu",
"militainment",
"militance",
"militancy",
"militant",
"militarisation",
"militarism",
"militarist",
"militarization",
"military",
"militia",
"militiaman",
"milium",
"milk",
"milkcap",
"milker",
"milkmaid",
"milkman",
"milkshake",
"milksop",
"milkwagon",
"milkweed",
"milkwort",
"mill",
"millais",
"millay",
"millboard",
"milldam",
"millenarian",
"millenarianism",
"millenarism",
"millenarist",
"millenary",
"millennium",
"millenniumism",
"millepede",
"miller",
"millerite",
"millet",
"millettia",
"milliammeter",
"milliampere",
"milliard",
"millibar",
"millicurie",
"millidegree",
"milliequivalent",
"millifarad",
"milligram",
"millihenry",
"millikan",
"milliliter",
"millilitre",
"millime",
"millimeter",
"millimetre",
"millimicron",
"milline",
"milliner",
"millinery",
"milling",
"million",
"millionaire",
"millionairess",
"millionth",
"milliped",
"millipede",
"milliradian",
"millirem",
"millisecond",
"millivolt",
"millivoltmeter",
"milliwatt",
"millpond",
"millrace",
"millrun",
"mills",
"millstone",
"millwheel",
"millwork",
"millwright",
"milne",
"milo",
"milometer",
"milontin",
"milord",
"milquetoast",
"milt",
"miltiades",
"miltomate",
"milton",
"miltonia",
"miltown",
"milvus",
"milwaukee",
"mimamsa",
"mime",
"mimeo",
"mimeograph",
"mimer",
"mimesis",
"mimic",
"mimicker",
"mimicry",
"mimidae",
"mimir",
"mimosa",
"mimosaceae",
"mimosoideae",
"mimus",
"mina",
"minah",
"minaret",
"mince",
"mincemeat",
"mincer",
"mind",
"mindanao",
"minden",
"minder",
"mindfulness",
"mindlessness",
"mindoro",
"mindset",
"mine",
"minefield",
"minelayer",
"minelaying",
"miner",
"mineral",
"mineralogist",
"mineralogy",
"minerva",
"mineshaft",
"minestrone",
"minesweeper",
"minesweeping",
"mineworker",
"ming",
"minge",
"minginess",
"mingling",
"mini",
"miniature",
"miniaturisation",
"miniaturist",
"miniaturization",
"minibar",
"minibike",
"minibus",
"minicab",
"minicar",
"minicomputer",
"miniconju",
"minim",
"minimalism",
"minimalist",
"minimisation",
"minimization",
"minimum",
"minimus",
"mining",
"minion",
"minipress",
"miniskirt",
"minister",
"ministrant",
"ministration",
"ministry",
"minisub",
"minisubmarine",
"minium",
"minivan",
"miniver",
"mink",
"minkowski",
"minneapolis",
"minnesota",
"minnesotan",
"minnewit",
"minniebush",
"minnow",
"minoan",
"minocin",
"minocycline",
"minor",
"minority",
"minors",
"minos",
"minotaur",
"minoxidil",
"minsk",
"minster",
"minstrel",
"minstrelsy",
"mint",
"mintage",
"minter",
"mintmark",
"minuartia",
"minuend",
"minuet",
"minuit",
"minus",
"minuscule",
"minute",
"minuteman",
"minuteness",
"minutes",
"minutia",
"minx",
"minyan",
"miocene",
"miosis",
"miotic",
"mips",
"mirabeau",
"mirabilis",
"miracle",
"mirage",
"mirasol",
"mire",
"miri",
"mirid",
"miridae",
"mirish",
"miro",
"mirounga",
"mirror",
"mirth",
"mirthfulness",
"misadventure",
"misalignment",
"misalliance",
"misanthrope",
"misanthropist",
"misanthropy",
"misapplication",
"misapprehension",
"misbehavior",
"misbehaviour",
"misbeliever",
"miscalculation",
"miscarriage",
"miscegenation",
"miscellanea",
"miscellany",
"mischance",
"mischief",
"mischievousness",
"misconception",
"misconduct",
"misconstrual",
"misconstruction",
"miscount",
"miscreant",
"miscreation",
"miscue",
"misdating",
"misdeal",
"misdeed",
"misdemeanor",
"misdemeanour",
"misdirection",
"miser",
"miserableness",
"miserliness",
"misery",
"misestimation",
"misfeasance",
"misfire",
"misfit",
"misfortune",
"misgiving",
"misgovernment",
"mishap",
"mishegaas",
"mishegoss",
"mishmash",
"mishna",
"mishnah",
"mishpachah",
"mishpocha",
"misinformation",
"misleader",
"mismanagement",
"mismatch",
"misnomer",
"miso",
"misocainea",
"misogamist",
"misogamy",
"misogynism",
"misogynist",
"misogyny",
"misology",
"misoneism",
"misopedia",
"mispickel",
"misplacement",
"misplay",
"misprint",
"misquotation",
"misquote",
"misreading",
"misreckoning",
"misrule",
"miss",
"missal",
"misshapenness",
"missile",
"mission",
"missionary",
"missioner",
"missis",
"mississippi",
"mississippian",
"missive",
"missoula",
"missouri",
"missourian",
"misspelling",
"misstatement",
"misstep",
"missus",
"missy",
"mist",
"mistake",
"mistaking",
"mister",
"mistflower",
"mistiming",
"mistiness",
"mistletoe",
"mistral",
"mistranslation",
"mistreatment",
"mistress",
"mistrial",
"mistrust",
"misuse",
"mitchell",
"mitchella",
"mitchum",
"mite",
"mitella",
"miter",
"miterwort",
"mitford",
"mithan",
"mithra",
"mithracin",
"mithraicism",
"mithraism",
"mithraist",
"mithramycin",
"mithras",
"mithridates",
"mitigation",
"mitochondrion",
"mitogen",
"mitomycin",
"mitosis",
"mitra",
"mitre",
"mitrewort",
"mitsvah",
"mitt",
"mittelschmerz",
"mitten",
"mitterrand",
"mitzvah",
"miwok",
"mixer",
"mixing",
"mixologist",
"mixology",
"mixture",
"mizen",
"mizenmast",
"mizzen",
"mizzenmast",
"mizzle",
"mlitt",
"mmpi",
"mnemonic",
"mnemonics",
"mnemonist",
"mnemosyne",
"mniaceae",
"mnium",
"moan",
"moaner",
"moat",
"moban",
"mobcap",
"mobile",
"mobilisation",
"mobility",
"mobilization",
"mobius",
"mobocracy",
"mobster",
"mobula",
"mobulidae",
"mocambique",
"mocassin",
"moccasin",
"mocha",
"mock",
"mocker",
"mockernut",
"mockery",
"mockingbird",
"modal",
"modality",
"mode",
"model",
"modeler",
"modeling",
"modeller",
"modelling",
"modem",
"moderate",
"moderateness",
"moderation",
"moderationism",
"moderationist",
"moderatism",
"moderator",
"moderatorship",
"modern",
"modernisation",
"modernism",
"modernist",
"modernity",
"modernization",
"modernness",
"modestness",
"modesty",
"modicon",
"modicum",
"modification",
"modifier",
"modigliani",
"modillion",
"modiolus",
"modishness",
"modiste",
"mods",
"modulation",
"module",
"modulus",
"moehringia",
"mogadiscio",
"mogadishu",
"moghul",
"mogul",
"mohair",
"mohammad",
"mohammed",
"mohammedan",
"mohammedanism",
"moharram",
"mohave",
"mohawk",
"mohican",
"moho",
"mohorovicic",
"mohria",
"moiety",
"moirae",
"moirai",
"moire",
"moistener",
"moistening",
"moistness",
"moisture",
"mojarra",
"mojave",
"mojo",
"moke",
"moksa",
"mokulu",
"mola",
"molality",
"molar",
"molarity",
"molasses",
"mold",
"moldavia",
"moldboard",
"moldiness",
"molding",
"moldova",
"mole",
"molech",
"molecule",
"molehill",
"moleskin",
"molestation",
"molester",
"molidae",
"moliere",
"molindone",
"moline",
"molise",
"moll",
"mollah",
"molle",
"mollie",
"mollienesia",
"mollification",
"molluga",
"mollusc",
"mollusca",
"molluscum",
"mollusk",
"molly",
"mollycoddle",
"mollycoddler",
"mollymawk",
"molnar",
"moloch",
"molokai",
"molossidae",
"molothrus",
"molotov",
"molt",
"molter",
"molting",
"moluccas",
"molucella",
"molva",
"molybdenite",
"molybdenum",
"mombasa",
"mombin",
"moment",
"momentousness",
"momentum",
"momism",
"momma",
"mommsen",
"mommy",
"momordica",
"momos",
"momot",
"momotidae",
"momotus",
"momus",
"mona",
"monacan",
"monaco",
"monad",
"monal",
"monandry",
"monarch",
"monarchism",
"monarchist",
"monarchy",
"monarda",
"monardella",
"monario",
"monas",
"monastery",
"monastic",
"monasticism",
"monaul",
"monazite",
"monday",
"mondrian",
"monegasque",
"monera",
"moneran",
"moneron",
"moneses",
"monet",
"monetarism",
"monetarist",
"monetisation",
"monetization",
"money",
"moneybag",
"moneyer",
"moneygrubber",
"moneylender",
"moneymaker",
"moneymaking",
"moneyman",
"moneywort",
"monger",
"monggo",
"mongo",
"mongol",
"mongolia",
"mongolian",
"mongolianism",
"mongolic",
"mongolism",
"mongoloid",
"mongoose",
"mongrel",
"moniker",
"monilia",
"moniliaceae",
"moniliales",
"moniliasis",
"monism",
"monistat",
"monition",
"monitor",
"monitoring",
"monitrice",
"monk",
"monkey",
"monkeypod",
"monkfish",
"monkshood",
"monnet",
"mono",
"monoamine",
"monoblast",
"monocanthidae",
"monocanthus",
"monocarp",
"monochamus",
"monochromacy",
"monochromasy",
"monochromat",
"monochromatism",
"monochrome",
"monochromia",
"monocle",
"monocline",
"monoclonal",
"monocot",
"monocotyledon",
"monocotyledonae",
"monocotyledones",
"monocracy",
"monoculture",
"monocycle",
"monocyte",
"monocytosis",
"monod",
"monodon",
"monodontidae",
"monody",
"monogamist",
"monogamousness",
"monogamy",
"monogenesis",
"monogram",
"monograph",
"monogynist",
"monogyny",
"monohybrid",
"monohydrate",
"monolatry",
"monolingual",
"monolith",
"monologist",
"monologue",
"monomania",
"monomaniac",
"monomer",
"monomorium",
"mononeuropathy",
"monongahela",
"mononucleosis",
"monophony",
"monophthalmos",
"monophysite",
"monophysitism",
"monoplane",
"monoplegia",
"monopolisation",
"monopoliser",
"monopolist",
"monopolization",
"monopolizer",
"monopoly",
"monopsony",
"monorail",
"monorchidism",
"monorchism",
"monosaccharide",
"monosaccharose",
"monosemy",
"monosomy",
"monosyllable",
"monotheism",
"monotheist",
"monothelitism",
"monotone",
"monotony",
"monotremata",
"monotreme",
"monotropa",
"monotropaceae",
"monotype",
"monoxide",
"monroe",
"monrovia",
"mons",
"monsieur",
"monsignor",
"monsoon",
"monster",
"monstera",
"monstrance",
"monstrosity",
"montage",
"montagu",
"montaigne",
"montana",
"montanan",
"monte",
"montenegro",
"monterey",
"monterrey",
"montespan",
"montesquieu",
"montessori",
"monteverdi",
"montevideo",
"montez",
"montezuma",
"montfort",
"montgolfier",
"montgomery",
"month",
"monthly",
"montia",
"montmartre",
"montpelier",
"montrachet",
"montreal",
"montserrat",
"montserratian",
"monument",
"mooch",
"moocher",
"mood",
"moodiness",
"moody",
"moolah",
"moon",
"moonbeam",
"mooneye",
"moonfish",
"moonflower",
"moong",
"moonie",
"moonlight",
"moonlighter",
"moonseed",
"moonshell",
"moonshine",
"moonshiner",
"moonstone",
"moonwalk",
"moonwort",
"moor",
"moorage",
"moorbird",
"moorcock",
"moore",
"moorfowl",
"moorgame",
"moorhen",
"mooring",
"moorish",
"moorland",
"moorwort",
"moose",
"moosewood",
"moot",
"mopboard",
"mope",
"moped",
"mopes",
"mopper",
"moppet",
"mopping",
"moquelumnan",
"moquette",
"moraceae",
"moraine",
"moral",
"morale",
"moralisation",
"moralism",
"moralist",
"morality",
"moralization",
"moralizing",
"morals",
"morass",
"moratorium",
"moravia",
"moray",
"morbidity",
"morbidness",
"morbilli",
"morceau",
"morchella",
"morchellaceae",
"mordacity",
"mordant",
"mordva",
"mordvin",
"mordvinian",
"more",
"moreen",
"morel",
"morello",
"mores",
"morgan",
"morganite",
"morgantown",
"morgen",
"morgue",
"morion",
"morley",
"mormon",
"mormonism",
"mormons",
"morn",
"morning",
"moro",
"moroccan",
"morocco",
"moron",
"morone",
"moronity",
"moroseness",
"morosoph",
"morphallaxis",
"morphea",
"morpheme",
"morpheus",
"morphia",
"morphine",
"morphogenesis",
"morphology",
"morphophoneme",
"morphophonemics",
"morrigan",
"morrigu",
"morris",
"morrison",
"morristown",
"morrow",
"mors",
"morse",
"morsel",
"mortal",
"mortality",
"mortar",
"mortarboard",
"mortgage",
"mortgagee",
"mortgager",
"mortgagor",
"mortice",
"mortician",
"mortification",
"mortimer",
"mortise",
"mortmain",
"morton",
"mortuary",
"morula",
"morus",
"mosaic",
"mosaicism",
"mosan",
"mosander",
"moschus",
"moscow",
"moselle",
"moses",
"moshav",
"moslem",
"mosque",
"mosquito",
"mosquitofish",
"moss",
"mossad",
"mossback",
"mossbauer",
"mostaccioli",
"mosul",
"motacilla",
"motacillidae",
"mote",
"motel",
"motet",
"moth",
"mothball",
"mother",
"motherese",
"motherfucker",
"motherhood",
"motherland",
"motherliness",
"motherwell",
"motherwort",
"motif",
"motile",
"motilin",
"motility",
"motion",
"motionlessness",
"motivating",
"motivation",
"motivator",
"motive",
"motivity",
"motley",
"motmot",
"motoneuron",
"motor",
"motorbike",
"motorboat",
"motorbus",
"motorcade",
"motorcar",
"motorcoach",
"motorcycle",
"motorcycling",
"motorcyclist",
"motoring",
"motorisation",
"motorist",
"motorization",
"motorman",
"motormouth",
"motortruck",
"motorway",
"motown",
"motrin",
"mott",
"mottle",
"mottling",
"motto",
"moue",
"moufflon",
"mouflon",
"moujik",
"moukden",
"mould",
"mouldboard",
"moulding",
"moulin",
"moulmein",
"moult",
"moulter",
"moulting",
"mound",
"mount",
"mountain",
"mountaineer",
"mountaineering",
"mountainside",
"mountebank",
"mounter",
"mountie",
"mounties",
"mounting",
"mourner",
"mournfulness",
"mourning",
"mouse",
"mousepad",
"mouser",
"mousetrap",
"moussaka",
"mousse",
"moussorgsky",
"moustache",
"moustachio",
"mouth",
"mouthbreeder",
"mouthful",
"mouthpart",
"mouthpiece",
"mouthwash",
"mouton",
"movability",
"movable",
"movableness",
"move",
"movement",
"mover",
"movie",
"moviegoer",
"moviemaking",
"mower",
"moxie",
"moynihan",
"mozambican",
"mozambique",
"mozart",
"mozzarella",
"mpeg",
"mrem",
"mrna",
"mrta",
"msasa",
"msec",
"muadhdhin",
"muazzin",
"mubarak",
"much",
"muchness",
"mucilage",
"mucin",
"muck",
"muckheap",
"muckhill",
"muckle",
"muckraker",
"muckraking",
"mucoid",
"mucor",
"mucoraceae",
"mucorales",
"mucosa",
"mucoviscidosis",
"mucuna",
"mucus",
"mudcat",
"mudder",
"muddiness",
"muddle",
"mudguard",
"mudhif",
"mudra",
"mudskipper",
"mudslide",
"mudslinger",
"mudspringer",
"muenchen",
"muenster",
"muesli",
"muezzin",
"muff",
"muffin",
"muffle",
"muffler",
"mufti",
"mugful",
"muggee",
"mugger",
"mugginess",
"mugging",
"muggins",
"mugil",
"mugilidae",
"mugiloidea",
"mugshot",
"mugwort",
"mugwump",
"muhammad",
"muhammadan",
"muhammadanism",
"muhammedan",
"muharram",
"muharrum",
"muhlenbergia",
"muir",
"muishond",
"mujahadeen",
"mujahadein",
"mujahadin",
"mujahedeen",
"mujahedin",
"mujahid",
"mujahideen",
"mujahidin",
"mujik",
"mujtihad",
"mukalla",
"mukataa",
"mukden",
"mulatto",
"mulberry",
"mulch",
"mulct",
"mule",
"muleteer",
"muliebrity",
"mulishness",
"mull",
"mulla",
"mullah",
"mullein",
"muller",
"mullet",
"mullidae",
"mulligan",
"mulligatawny",
"mullion",
"mulloidichthys",
"mulloway",
"mullus",
"multiflora",
"multimedia",
"multinomial",
"multiple",
"multiplex",
"multiplexer",
"multiplicand",
"multiplication",
"multiplicity",
"multiplier",
"multiprocessing",
"multiprocessor",
"multistage",
"multitude",
"multivalence",
"multivalency",
"multiversity",
"multivitamin",
"mulwi",
"mumbai",
"mumble",
"mumbler",
"mumbling",
"mummer",
"mummery",
"mummichog",
"mummification",
"mummy",
"mumps",
"mumpsimus",
"munch",
"munchausen",
"munchener",
"muncher",
"munchhausen",
"muncie",
"munda",
"mundaneness",
"mundanity",
"mung",
"munggo",
"munich",
"municipality",
"munificence",
"muniments",
"munition",
"munj",
"munja",
"munjeet",
"munjuk",
"munro",
"muntiacus",
"muntingia",
"muntjac",
"muon",
"muraenidae",
"mural",
"muralist",
"muramidase",
"murder",
"murderee",
"murderer",
"murderess",
"murderousness",
"murdoch",
"muridae",
"murillo",
"murine",
"muritaniya",
"murk",
"murkiness",
"murmansk",
"murmur",
"murmuration",
"murmurer",
"murmuring",
"muroidea",
"murphy",
"murrain",
"murray",
"murre",
"murrow",
"murrumbidgee",
"musa",
"musaceae",
"musales",
"musca",
"muscadel",
"muscadelle",
"muscadet",
"muscadine",
"muscardinus",
"muscari",
"muscat",
"muscatel",
"musci",
"muscicapa",
"muscicapidae",
"muscidae",
"muscivora",
"muscle",
"musclebuilder",
"musclebuilding",
"muscleman",
"muscoidea",
"muscovite",
"muscovy",
"muscularity",
"musculature",
"musculus",
"musd",
"muse",
"muser",
"musette",
"museum",
"musgoi",
"musgu",
"mush",
"musher",
"mushiness",
"mushroom",
"musial",
"music",
"musical",
"musicality",
"musicalness",
"musician",
"musicianship",
"musicologist",
"musicology",
"musing",
"musjid",
"musk",
"muskat",
"muskellunge",
"musket",
"musketeer",
"musketry",
"muskhogean",
"muskiness",
"muskmelon",
"muskogean",
"muskogee",
"muskrat",
"muskwood",
"muslim",
"muslimah",
"muslimism",
"muslin",
"musnud",
"musophaga",
"musophagidae",
"musophobia",
"musquash",
"muss",
"mussel",
"musset",
"mussiness",
"mussitation",
"mussolini",
"mussorgsky",
"must",
"mustache",
"mustachio",
"mustagh",
"mustang",
"mustard",
"mustela",
"mustelid",
"mustelidae",
"musteline",
"mustelus",
"muster",
"musth",
"mustiness",
"mutability",
"mutableness",
"mutagen",
"mutagenesis",
"mutamycin",
"mutant",
"mutation",
"mutawa",
"mutchkin",
"mute",
"muteness",
"mutilation",
"mutilator",
"mutillidae",
"mutineer",
"mutinus",
"mutiny",
"mutisia",
"mutism",
"muton",
"mutsuhito",
"mutt",
"mutter",
"mutterer",
"muttering",
"mutton",
"muttonfish",
"muttonhead",
"mutualism",
"mutuality",
"mutualness",
"muumuu",
"muybridge",
"muzhik",
"muzjik",
"muztag",
"muztagh",
"muzzle",
"muzzler",
"mwanza",
"mwera",
"myaceae",
"myacidae",
"myadestes",
"myalgia",
"myanmar",
"myasthenia",
"mycelium",
"mycenae",
"mycenaen",
"mycetophilidae",
"mycobacteria",
"mycobacterium",
"mycologist",
"mycology",
"mycomycin",
"mycophage",
"mycophagist",
"mycophagy",
"mycoplasma",
"mycoplasmatales",
"mycosis",
"mycostatin",
"mycotoxin",
"mycrosporidia",
"mycteria",
"mycteroperca",
"myctophidae",
"mydriasis",
"mydriatic",
"myelatelia",
"myelencephalon",
"myelin",
"myeline",
"myelinisation",
"myelinization",
"myelitis",
"myeloblast",
"myelocyte",
"myelofibrosis",
"myelogram",
"myelography",
"myeloma",
"myiasis",
"mylanta",
"mylar",
"myliobatidae",
"mylitta",
"mylodon",
"mylodontid",
"mylodontidae",
"myna",
"mynah",
"myocardiopathy",
"myocarditis",
"myocardium",
"myocastor",
"myoclonus",
"myodynia",
"myofibril",
"myofibrilla",
"myoglobin",
"myoglobinuria",
"myogram",
"myology",
"myoma",
"myometritis",
"myometrium",
"myomorpha",
"myonecrosis",
"myopathy",
"myope",
"myopia",
"myopus",
"myosarcoma",
"myosin",
"myosis",
"myositis",
"myosotis",
"myotic",
"myotis",
"myotomy",
"myotonia",
"myrcia",
"myrciaria",
"myrdal",
"myriad",
"myriagram",
"myriameter",
"myriametre",
"myriapod",
"myriapoda",
"myrica",
"myricaceae",
"myricales",
"myricaria",
"myringa",
"myringectomy",
"myringoplasty",
"myringotomy",
"myriophyllum",
"myristica",
"myristicaceae",
"myrmecia",
"myrmecobius",
"myrmecophaga",
"myrmecophagidae",
"myrmecophile",
"myrmecophyte",
"myrmeleon",
"myrmeleontidae",
"myrmidon",
"myrobalan",
"myroxylon",
"myrrh",
"myrrhis",
"myrsinaceae",
"myrsine",
"myrtaceae",
"myrtales",
"myrtillocactus",
"myrtle",
"myrtus",
"mysidacea",
"mysidae",
"mysis",
"mysoandry",
"mysoline",
"mysophilia",
"mysophobia",
"mysore",
"mystery",
"mystic",
"mysticeti",
"mysticism",
"mystification",
"mystifier",
"mystique",
"myth",
"mythologisation",
"mythologist",
"mythologization",
"mythology",
"mytilene",
"mytilid",
"mytilidae",
"mytilus",
"myxedema",
"myxine",
"myxinidae",
"myxiniformes",
"myxinikela",
"myxinoidea",
"myxinoidei",
"myxobacter",
"myxobacterales",
"myxobacteria",
"myxobacteriales",
"myxobacterium",
"myxocephalus",
"myxoedema",
"myxoma",
"myxomatosis",
"myxomycete",
"myxomycetes",
"myxomycota",
"myxophyceae",
"myxosporidia",
"myxosporidian",
"myxovirus",
"naan",
"nabalus",
"nablus",
"nabob",
"nabokov",
"naboom",
"nabu",
"nabumetone",
"nacelle",
"nacho",
"nacimiento",
"nacre",
"nada",
"nadir",
"nadolol",
"nadp",
"naemorhedus",
"nafcil",
"nafcillin",
"nafta",
"nafud",
"naga",
"nagami",
"nagano",
"nagari",
"nagasaki",
"nageia",
"nagger",
"nagi",
"nagoya",
"nahuatl",
"nahum",
"naiad",
"naiadaceae",
"naiadales",
"naias",
"naif",
"naiki",
"nail",
"nailbrush",
"nailer",
"nailfile",
"nailhead",
"nailrod",
"nainsook",
"naira",
"nairobi",
"naismith",
"naiveness",
"naivete",
"naivety",
"naja",
"najadaceae",
"najas",
"najd",
"nakedness",
"nakedwood",
"nakuru",
"nalchik",
"nalfon",
"nalline",
"nalorphine",
"naloxone",
"naltrexone",
"name",
"nameko",
"namelessness",
"nameplate",
"namer",
"names",
"namesake",
"namibia",
"namibian",
"naming",
"nammad",
"nammu",
"namoi",
"nampa",
"namtar",
"namtaru",
"namur",
"nanaimo",
"nanak",
"nance",
"nancere",
"nanchang",
"nancy",
"nandrolone",
"nandu",
"nanism",
"nanjing",
"nankeen",
"nanking",
"nanna",
"nanning",
"nanny",
"nanocephaly",
"nanogram",
"nanometer",
"nanometre",
"nanomia",
"nanophthalmos",
"nanosecond",
"nanotechnology",
"nanotube",
"nanovolt",
"nansen",
"nantes",
"nanticoke",
"nantua",
"nantucket",
"nanus",
"naomi",
"napa",
"napaea",
"napalm",
"nape",
"napery",
"naphazoline",
"naphtha",
"naphthalene",
"naphthol",
"naphthoquinone",
"napier",
"napkin",
"naples",
"napoleon",
"napoli",
"nappy",
"naprapath",
"naprapathy",
"naprosyn",
"naproxen",
"napu",
"naqua",
"nara",
"naranjilla",
"narc",
"narcan",
"narcism",
"narcissism",
"narcissist",
"narcissus",
"narcist",
"narcolepsy",
"narcoleptic",
"narcosis",
"narcoterrorism",
"narcotic",
"narcotraffic",
"nard",
"nardil",
"nardo",
"nardoo",
"narghile",
"nargileh",
"naris",
"nark",
"narration",
"narrative",
"narrator",
"narrow",
"narrowboat",
"narrowing",
"narrowness",
"narthecium",
"narthex",
"narwal",
"narwhal",
"narwhale",
"nasa",
"nasal",
"nasalis",
"nasalisation",
"nasality",
"nasalization",
"nascence",
"nascency",
"nasdaq",
"naseby",
"nash",
"nashville",
"nasion",
"nasopharynx",
"nassau",
"nasser",
"nast",
"nastiness",
"nasturtium",
"nasua",
"natal",
"natality",
"natantia",
"natation",
"natator",
"natatorium",
"natchez",
"nates",
"naticidae",
"nation",
"national",
"nationalisation",
"nationalism",
"nationalist",
"nationality",
"nationalization",
"nationhood",
"native",
"nativeness",
"nativism",
"nativist",
"nativity",
"nato",
"natriuresis",
"natrix",
"natrolite",
"natta",
"natterjack",
"nattiness",
"natural",
"naturalisation",
"naturalism",
"naturalist",
"naturalization",
"naturalness",
"nature",
"naturism",
"naturist",
"naturopath",
"naturopathy",
"nauch",
"nauclea",
"naucrates",
"naught",
"naughtiness",
"naumachia",
"naumachy",
"naupathia",
"nauru",
"nauruan",
"nausea",
"nauseant",
"nauseatingness",
"nautch",
"nautilidae",
"nautilus",
"navaho",
"navajo",
"navane",
"navarino",
"nave",
"navel",
"navicular",
"navigability",
"navigation",
"navigator",
"navratilova",
"navvy",
"navy",
"nawab",
"nawcwpns",
"naysayer",
"naysaying",
"nazarene",
"nazareth",
"naze",
"nazi",
"nazification",
"naziism",
"nazimova",
"nazism",
"ncdc",
"ndebele",
"ndjamena",
"neandertal",
"neanderthal",
"neap",
"neapolitan",
"nearness",
"nearside",
"nearsightedness",
"neatness",
"nebbech",
"nebbish",
"nebcin",
"nebe",
"nebiim",
"nebn",
"nebo",
"nebraska",
"nebraskan",
"nebuchadnezzar",
"nebuchadrezzar",
"nebula",
"nebule",
"nebuliser",
"nebulizer",
"necessary",
"necessitarian",
"necessity",
"neck",
"neckar",
"neckband",
"neckcloth",
"necker",
"neckerchief",
"necking",
"necklace",
"necklet",
"neckline",
"neckpiece",
"necktie",
"neckwear",
"necrobiosis",
"necrology",
"necrolysis",
"necromancer",
"necromancy",
"necromania",
"necrophagia",
"necrophagy",
"necrophilia",
"necrophilism",
"necropolis",
"necropsy",
"necrosis",
"nectar",
"nectarine",
"nectary",
"necturus",
"nederland",
"need",
"needer",
"neediness",
"needle",
"needlebush",
"needlecraft",
"needlefish",
"needlepoint",
"needlewoman",
"needlewood",
"needlework",
"needleworker",
"needy",
"neel",
"neem",
"neencephalon",
"nefariousness",
"nefazodone",
"nefertiti",
"nefud",
"negaprion",
"negation",
"negative",
"negativeness",
"negativism",
"negativist",
"negativity",
"negatron",
"negev",
"neggram",
"neglect",
"neglecter",
"neglectfulness",
"neglige",
"negligee",
"negligence",
"negotiant",
"negotiation",
"negotiator",
"negotiatress",
"negotiatrix",
"negritude",
"negro",
"negroid",
"negus",
"nehemiah",
"nehru",
"neigh",
"neighbor",
"neighborhood",
"neighborliness",
"neighbour",
"neighbourhood",
"neighbourliness",
"nejd",
"nekton",
"nelfinavir",
"nelson",
"nelumbo",
"nelumbonaceae",
"nematocera",
"nematoda",
"nematode",
"nembutal",
"nemea",
"nemertea",
"nemertean",
"nemertina",
"nemertine",
"nemesis",
"nemophila",
"nenets",
"nentsi",
"nentsy",
"neobiotic",
"neoceratodus",
"neoclassicism",
"neoclassicist",
"neocolonialism",
"neocon",
"neoconservatism",
"neoconservative",
"neocortex",
"neodymium",
"neoencephalon",
"neofiber",
"neohygrophorus",
"neolentinus",
"neoliberal",
"neoliberalism",
"neolith",
"neolithic",
"neologism",
"neologist",
"neology",
"neomycin",
"neomys",
"neon",
"neonate",
"neonatology",
"neopallium",
"neophobia",
"neophron",
"neophyte",
"neoplasia",
"neoplasm",
"neoplatonism",
"neoplatonist",
"neopolitan",
"neoprene",
"neoromanticism",
"neosho",
"neosporin",
"neostigmine",
"neoteny",
"neotoma",
"neotony",
"nepa",
"nepal",
"nepalese",
"nepali",
"nepenthaceae",
"nepenthes",
"nepeta",
"nepheline",
"nephelinite",
"nephelite",
"nephelium",
"nephew",
"nephology",
"nephoscope",
"nephralgia",
"nephrectomy",
"nephrite",
"nephritis",
"nephroblastoma",
"nephrolepis",
"nephrolith",
"nephrolithiasis",
"nephrology",
"nephron",
"nephropathy",
"nephrops",
"nephropsidae",
"nephroptosia",
"nephroptosis",
"nephrosclerosis",
"nephrosis",
"nephrotomy",
"nephrotoxin",
"nephthys",
"nephthytis",
"nepidae",
"nepotism",
"nepotist",
"neptune",
"neptunium",
"nerd",
"nereid",
"nereus",
"nergal",
"nerita",
"neritid",
"neritidae",
"neritina",
"nerium",
"nernst",
"nero",
"nerodia",
"nerthus",
"neruda",
"nerva",
"nerve",
"nervelessness",
"nerveroot",
"nerves",
"nervi",
"nervousness",
"nervure",
"nervus",
"nescience",
"nesokia",
"ness",
"nesselrode",
"nessie",
"nest",
"nester",
"nestle",
"nestling",
"nestor",
"nestorian",
"nestorianism",
"nestorius",
"netball",
"netherlander",
"netherlands",
"netherworld",
"netkeeper",
"netminder",
"netscape",
"netting",
"nettle",
"network",
"neumann",
"neuralgia",
"neuralgy",
"neurasthenia",
"neurasthenic",
"neurectomy",
"neurilemma",
"neurilemoma",
"neurinoma",
"neuritis",
"neuroanatomy",
"neurobiologist",
"neurobiology",
"neuroblast",
"neuroblastoma",
"neurochemical",
"neurodermatitis",
"neuroepithelium",
"neuroethics",
"neurofibroma",
"neurogenesis",
"neuroglia",
"neurogliacyte",
"neurohormone",
"neurohypophysis",
"neurolemma",
"neuroleptic",
"neurolinguist",
"neurologist",
"neurology",
"neurolysin",
"neuroma",
"neuromarketing",
"neuron",
"neurontin",
"neuropathy",
"neurophysiology",
"neuropil",
"neuropile",
"neuroplasty",
"neuropsychiatry",
"neuropsychology",
"neuroptera",
"neuropteran",
"neuropteron",
"neurosarcoma",
"neuroscience",
"neuroscientist",
"neurosis",
"neurospora",
"neurosurgeon",
"neurosurgery",
"neurosyphilis",
"neurotic",
"neuroticism",
"neurotoxin",
"neurotrichus",
"neurotropism",
"neuter",
"neutering",
"neutral",
"neutralisation",
"neutralism",
"neutralist",
"neutrality",
"neutralization",
"neutrino",
"neutron",
"neutropenia",
"neutrophil",
"neutrophile",
"neva",
"nevada",
"nevadan",
"neve",
"nevelson",
"nevirapine",
"nevis",
"nevus",
"newari",
"newark",
"newbie",
"newborn",
"newburgh",
"newcastle",
"newcomb",
"newcomer",
"newel",
"newfoundland",
"newgate",
"newlywed",
"newman",
"newmarket",
"newness",
"newport",
"news",
"newsagent",
"newsboy",
"newsbreak",
"newscast",
"newscaster",
"newsdealer",
"newsflash",
"newsletter",
"newsman",
"newsmonger",
"newspaper",
"newspapering",
"newspaperman",
"newspaperwoman",
"newspeak",
"newsperson",
"newsprint",
"newsreader",
"newsreel",
"newsroom",
"newssheet",
"newsstand",
"newsvendor",
"newswoman",
"newsworthiness",
"newswriter",
"newt",
"newton",
"newtonian",
"nexus",
"nganasan",
"ngultrum",
"nguni",
"ngwee",
"niacin",
"niagara",
"niamey",
"nibble",
"nibbler",
"nibelung",
"nibelungenlied",
"niblick",
"nicad",
"nicaea",
"nicandra",
"nicaragua",
"nicaraguan",
"nice",
"niceness",
"nicety",
"niche",
"nicholas",
"nichrome",
"nick",
"nickel",
"nickelodeon",
"nicker",
"nicklaus",
"nicknack",
"nickname",
"nicolson",
"nicosia",
"nicotiana",
"nicotine",
"nictation",
"nictitation",
"nicu",
"nidaros",
"nidation",
"niddm",
"nidularia",
"nidulariaceae",
"nidulariales",
"nidus",
"niebuhr",
"niece",
"nielsen",
"nierembergia",
"nietzsche",
"nifedipine",
"niff",
"nigella",
"niger",
"nigeria",
"nigerian",
"nigerien",
"niggard",
"niggardliness",
"niggardness",
"niggler",
"night",
"nightbird",
"nightcap",
"nightclothes",
"nightclub",
"nightcrawler",
"nightdress",
"nightfall",
"nightgown",
"nighthawk",
"nightie",
"nightingale",
"nightjar",
"nightlife",
"nightmare",
"nightrider",
"nightshade",
"nightshirt",
"nightspot",
"nightstick",
"nighttime",
"nightwalker",
"nightwear",
"nightwork",
"nigroporus",
"nihau",
"nihil",
"nihilism",
"nihilist",
"nihility",
"nihon",
"nijinsky",
"nijmegen",
"nike",
"nile",
"nilgai",
"nilotic",
"nilsson",
"nimbleness",
"nimblewill",
"nimbus",
"nimby",
"nimiety",
"nimitz",
"nimravus",
"nimrod",
"nina",
"nincompoop",
"nine",
"ninepence",
"ninepin",
"ninepins",
"niner",
"nineteen",
"nineteenth",
"nineties",
"ninetieth",
"ninety",
"nineveh",
"ningal",
"ningirsu",
"ningishzida",
"ninhursag",
"ninib",
"ninigi",
"ninja",
"ninjitsu",
"ninjutsu",
"ninkharsag",
"ninkhursag",
"ninny",
"ninon",
"ninth",
"nintoo",
"nintu",
"ninurta",
"niobe",
"niobite",
"niobium",
"niobrara",
"nipa",
"nipper",
"nipple",
"nippon",
"nipponese",
"nipr",
"niqaabi",
"niqab",
"nirvana",
"nisan",
"nisei",
"nissan",
"nist",
"nisus",
"nitella",
"niter",
"nitpicker",
"nitramine",
"nitrate",
"nitrazepam",
"nitre",
"nitride",
"nitrification",
"nitril",
"nitrile",
"nitrite",
"nitrobacter",
"nitrobacteria",
"nitrobacterium",
"nitrobenzene",
"nitrocalcite",
"nitrocellulose",
"nitrochloroform",
"nitrocotton",
"nitrofuran",
"nitrofurantoin",
"nitrogen",
"nitrogenase",
"nitroglycerin",
"nitroglycerine",
"nitrosobacteria",
"nitrosomonas",
"nitrospan",
"nitrostat",
"nitweed",
"nitwit",
"nivose",
"nixon",
"njord",
"njorth",
"nlrb",
"nnrti",
"noaa",
"noah",
"nobel",
"nobelist",
"nobelium",
"nobility",
"noble",
"nobleman",
"nobleness",
"noblesse",
"noblewoman",
"nobody",
"noctambulation",
"noctambulism",
"noctambulist",
"noctiluca",
"noctua",
"noctuid",
"noctuidae",
"nocturia",
"nocturne",
"noddle",
"node",
"nodule",
"noel",
"noemi",
"noesis",
"noether",
"nogales",
"noggin",
"nogging",
"noguchi",
"noise",
"noiselessness",
"noisemaker",
"noisiness",
"noisomeness",
"nolina",
"noma",
"nomad",
"nombril",
"nome",
"nomenclature",
"nomenklatura",
"nomia",
"nominal",
"nominalism",
"nominalist",
"nomination",
"nominative",
"nominator",
"nominee",
"nomogram",
"nomograph",
"nonabsorbency",
"nonacceptance",
"nonachievement",
"nonachiever",
"nonage",
"nonagenarian",
"nonaggression",
"nonagon",
"nonalignment",
"nonalinement",
"nonallele",
"nonappearance",
"nonattendance",
"nonattender",
"nonbeing",
"nonbeliever",
"noncandidate",
"nonce",
"nonchalance",
"noncitizen",
"noncom",
"noncombatant",
"noncompliance",
"noncompliant",
"nonconductor",
"nonconformance",
"nonconformism",
"nonconformist",
"nonconformity",
"nondescript",
"nondevelopment",
"nondisjunction",
"nondrinker",
"nondriver",
"none",
"nonentity",
"nonequivalence",
"nones",
"nonessential",
"nonesuch",
"nonevent",
"nonexistence",
"nonfeasance",
"nonfiction",
"nonindulgence",
"noninterference",
"nonintervention",
"nonmember",
"nonmetal",
"nonobservance",
"nonoccurrence",
"nonpareil",
"nonparticipant",
"nonpartisan",
"nonpartisanship",
"nonpartizan",
"nonpayment",
"nonperformance",
"nonperson",
"nonprofit",
"nonreader",
"nonremittal",
"nonresident",
"nonresistance",
"nonsense",
"nonsensicality",
"nonsmoker",
"nonstarter",
"nonsteroid",
"nonsteroidal",
"nonstop",
"nonsuch",
"nontricyclic",
"nonuniformity",
"nonviolence",
"nonworker",
"noodle",
"nook",
"nookie",
"nooky",
"noon",
"noonday",
"noontide",
"noose",
"nootka",
"nopal",
"nopalea",
"noradrenaline",
"nordic",
"noreaster",
"noreg",
"norepinephrine",
"norethandrolone",
"norethindrone",
"norethynodrel",
"norflex",
"norfolk",
"norge",
"norgestrel",
"noria",
"norinyl",
"norlestrin",
"norlutin",
"norm",
"norma",
"normal",
"normalcy",
"normalisation",
"normaliser",
"normality",
"normalization",
"normalizer",
"norman",
"normandie",
"normandy",
"normodyne",
"normothermia",
"norn",
"norris",
"norrish",
"norse",
"norseman",
"north",
"northampton",
"northeast",
"northeaster",
"northeastward",
"norther",
"northerly",
"northern",
"northerner",
"northernness",
"northland",
"northman",
"northrop",
"northumberland",
"northumbria",
"northward",
"northwest",
"northwester",
"northwestward",
"nortriptyline",
"noruz",
"norvasc",
"norvir",
"norway",
"norwegian",
"nose",
"nosebag",
"noseband",
"nosebleed",
"nosecount",
"nosedive",
"nosegay",
"nosepiece",
"nosewheel",
"nosh",
"nosher",
"nosiness",
"nosology",
"nostalgia",
"nostoc",
"nostocaceae",
"nostradamus",
"nostril",
"nostrum",
"notability",
"notable",
"notary",
"notation",
"notch",
"note",
"notebook",
"notecase",
"notechis",
"notemigonus",
"notepad",
"notepaper",
"nothing",
"nothingness",
"nothings",
"nothofagus",
"nothosaur",
"nothosauria",
"notice",
"noticeability",
"noticeableness",
"noticer",
"notification",
"notion",
"notochord",
"notomys",
"notonecta",
"notonectidae",
"notophthalmus",
"notoriety",
"notornis",
"notoryctidae",
"notoryctus",
"notostraca",
"notropis",
"notturno",
"nouakchott",
"nougat",
"nought",
"noumenon",
"noun",
"nourishment",
"nous",
"nova",
"novation",
"novel",
"novelette",
"novelisation",
"novelist",
"novelization",
"novella",
"novelty",
"november",
"novena",
"novgorod",
"novial",
"novice",
"noviciate",
"novillada",
"novillero",
"novitiate",
"novobiocin",
"novocain",
"novocaine",
"novosibirsk",
"nowadays",
"nowhere",
"nowness",
"nowrooz",
"nowruz",
"noxiousness",
"noyes",
"nozzle",
"nrem",
"nrna",
"nrti",
"nsaid",
"nswc",
"ntis",
"nuance",
"nubbin",
"nubbiness",
"nubble",
"nubia",
"nubian",
"nucellus",
"nucha",
"nucifraga",
"nuclease",
"nucleole",
"nucleolus",
"nucleon",
"nucleonics",
"nucleoplasm",
"nucleoprotein",
"nucleoside",
"nucleosynthesis",
"nucleotide",
"nucleus",
"nuda",
"nude",
"nudeness",
"nudge",
"nudger",
"nudibranch",
"nudibranchia",
"nudism",
"nudist",
"nudity",
"nudnick",
"nudnik",
"nuffield",
"nugget",
"nuisance",
"nuke",
"null",
"nullah",
"nullification",
"nullifier",
"nullipara",
"nullity",
"numbat",
"number",
"numbering",
"numberplate",
"numbers",
"numbfish",
"numbness",
"numdah",
"numen",
"numenius",
"numeracy",
"numeral",
"numeration",
"numerator",
"numerologist",
"numerology",
"numerosity",
"numerousness",
"numida",
"numidia",
"numidian",
"numididae",
"numidinae",
"numismatics",
"numismatist",
"numismatologist",
"numismatology",
"nummulite",
"nummulitidae",
"numskull",
"nunavut",
"nuncio",
"nung",
"nunnery",
"nuphar",
"nuprin",
"nuptials",
"nuptse",
"nuremberg",
"nureyev",
"nurnberg",
"nurse",
"nurseling",
"nursemaid",
"nurser",
"nursery",
"nurseryman",
"nursing",
"nursling",
"nurturance",
"nurture",
"nusku",
"nutation",
"nutcase",
"nutcracker",
"nutgrass",
"nuthatch",
"nuthouse",
"nutlet",
"nutmeg",
"nutria",
"nutrient",
"nutriment",
"nutrition",
"nutritionist",
"nutritiousness",
"nutritiveness",
"nutsedge",
"nutshell",
"nutter",
"nuwc",
"nuytsia",
"nwbn",
"nwbw",
"nyala",
"nyamuragira",
"nyamwezi",
"nyasaland",
"nybble",
"nyctaginaceae",
"nyctaginia",
"nyctalopia",
"nyctanassa",
"nyctereutes",
"nycticebus",
"nycticorax",
"nyctimene",
"nyctophobia",
"nycturia",
"nydrazid",
"nyiragongo",
"nylghai",
"nylghau",
"nylon",
"nylons",
"nymph",
"nymphaea",
"nymphaeaceae",
"nymphalid",
"nymphalidae",
"nymphalis",
"nymphet",
"nymphicus",
"nympho",
"nympholepsy",
"nympholept",
"nymphomania",
"nymphomaniac",
"nynorsk",
"nypa",
"nyse",
"nyssa",
"nyssaceae",
"nystagmus",
"nystan",
"nystatin",
"oahu",
"oakland",
"oakley",
"oakum",
"oarfish",
"oarlock",
"oarsman",
"oarsmanship",
"oarswoman",
"oasis",
"oast",
"oatcake",
"oates",
"oath",
"oatmeal",
"oaxaca",
"obadiah",
"obama",
"obbligato",
"obduracy",
"obeah",
"obeche",
"obechi",
"obedience",
"obeisance",
"obelion",
"obelisk",
"oberson",
"obesity",
"obfuscation",
"obiism",
"obit",
"obituary",
"object",
"objectification",
"objection",
"objective",
"objectiveness",
"objectivity",
"objector",
"objurgation",
"oblate",
"oblateness",
"oblation",
"obligation",
"obligato",
"obliger",
"obligingness",
"oblique",
"obliqueness",
"obliquity",
"obliteration",
"obliterator",
"oblivion",
"obliviousness",
"oblong",
"oblongness",
"obloquy",
"obnoxiousness",
"oboe",
"oboist",
"obolus",
"obscenity",
"obscurantism",
"obscurantist",
"obscureness",
"obscurity",
"obsequiousness",
"obsequy",
"observance",
"observation",
"observatory",
"observer",
"obsession",
"obsessive",
"obsessiveness",
"obsessivity",
"obsidian",
"obsolescence",
"obsoleteness",
"obstacle",
"obstetrician",
"obstetrics",
"obstinacy",
"obstinance",
"obstipation",
"obstructer",
"obstruction",
"obstructionism",
"obstructionist",
"obstructor",
"obstruent",
"obtainment",
"obtention",
"obtrusiveness",
"obturator",
"obtuseness",
"obverse",
"obviation",
"obviousness",
"ocarina",
"occam",
"occasion",
"occasions",
"occident",
"occidental",
"occidentalism",
"occiput",
"occitan",
"occlusion",
"occlusive",
"occult",
"occultation",
"occultism",
"occultist",
"occupancy",
"occupant",
"occupation",
"occupier",
"occurrence",
"occurrent",
"ocean",
"oceanaut",
"oceanfront",
"oceania",
"oceanic",
"oceanica",
"oceanid",
"oceanites",
"oceanographer",
"oceanography",
"oceanology",
"oceanus",
"ocellus",
"ocelot",
"ocher",
"ochlocracy",
"ochna",
"ochnaceae",
"ochoa",
"ochotona",
"ochotonidae",
"ochre",
"ochroma",
"ochronosis",
"ochs",
"ocimum",
"ockham",
"ocotillo",
"octad",
"octagon",
"octahedron",
"octameter",
"octane",
"octans",
"octant",
"octave",
"octavian",
"octavo",
"octet",
"octette",
"octillion",
"october",
"octoberfest",
"octogenarian",
"octonary",
"octopod",
"octopoda",
"octopodidae",
"octopus",
"octoroon",
"octosyllable",
"octroi",
"ocular",
"oculism",
"oculist",
"oculomotor",
"oculus",
"ocyurus",
"odalisque",
"oddball",
"oddity",
"oddment",
"oddments",
"oddness",
"odds",
"oder",
"odesa",
"odessa",
"odets",
"odin",
"odiousness",
"odist",
"odium",
"odoacer",
"odobenidae",
"odobenus",
"odocoileus",
"odometer",
"odonata",
"odonate",
"odontalgia",
"odontaspididae",
"odontaspis",
"odontiasis",
"odontoceti",
"odontoglossum",
"odontology",
"odontophorus",
"odor",
"odour",
"odovacar",
"odovakar",
"odynophagia",
"odysseus",
"odyssey",
"oecanthus",
"oecumenism",
"oedema",
"oedipus",
"oedogoniaceae",
"oedogoniales",
"oedogonium",
"oenanthe",
"oengus",
"oenologist",
"oenology",
"oenomel",
"oenophile",
"oenothera",
"oersted",
"oesophagitis",
"oesophagoscope",
"oesophagus",
"oesterreich",
"oestradiol",
"oestridae",
"oestriol",
"oestrogen",
"oestrone",
"oestrus",
"oeuvre",
"offal",
"offbeat",
"offenbach",
"offence",
"offender",
"offense",
"offensive",
"offensiveness",
"offer",
"offerer",
"offering",
"offeror",
"offertory",
"office",
"officeholder",
"officer",
"official",
"officialdom",
"officialese",
"officiant",
"officiating",
"officiation",
"officiousness",
"offing",
"offprint",
"offset",
"offshoot",
"offside",
"offspring",
"offstage",
"oftenness",
"ogalala",
"ogcocephalidae",
"ogden",
"ogdoad",
"ogee",
"ogive",
"oglala",
"ogler",
"ogre",
"ogress",
"ohio",
"ohioan",
"ohmage",
"ohmmeter",
"oilbird",
"oilcan",
"oilcloth",
"oiler",
"oilfield",
"oilfish",
"oiliness",
"oilman",
"oilpaper",
"oilrig",
"oilseed",
"oilskin",
"oilstone",
"oilstove",
"oink",
"ointment",
"oireachtas",
"ojibwa",
"ojibway",
"okapi",
"okapia",
"okay",
"okeechobee",
"okeh",
"oken",
"okenfuss",
"okey",
"okinawa",
"oklahoma",
"oklahoman",
"okra",
"oktoberfest",
"oldenburg",
"oldfield",
"oldie",
"oldness",
"oldster",
"oldtimer",
"oldwench",
"oldwife",
"olea",
"oleaceae",
"oleaginousness",
"oleales",
"oleander",
"oleandra",
"oleandraceae",
"olearia",
"oleaster",
"olecranon",
"oled",
"olefin",
"olefine",
"olein",
"oleo",
"oleomargarine",
"oleoresin",
"olfaction",
"olfersia",
"olibanum",
"oligarch",
"oligarchy",
"oligo",
"oligocene",
"oligochaeta",
"oligochaete",
"oligoclase",
"oligodactyly",
"oligodendria",
"oligodendrocyte",
"oligodendroglia",
"oligodontia",
"oligomenorrhea",
"oligonucleotide",
"oligoplites",
"oligopoly",
"oligoporus",
"oligosaccharide",
"oligospermia",
"oliguria",
"olimbos",
"olive",
"olivenite",
"oliver",
"olivier",
"olivine",
"olla",
"ollari",
"olmec",
"olmsted",
"ology",
"olympia",
"olympiad",
"olympian",
"olympics",
"olympus",
"omaha",
"oman",
"omani",
"omasum",
"omayyad",
"ombu",
"ombudsman",
"omdurman",
"omega",
"omelet",
"omelette",
"omen",
"omentum",
"omeprazole",
"omerta",
"omicron",
"omission",
"omiya",
"ommastrephes",
"ommatidium",
"ommiad",
"omnibus",
"omnipotence",
"omnipresence",
"omnirange",
"omniscience",
"omnivore",
"omomyid",
"omophagia",
"omotic",
"omphalocele",
"omphalos",
"omphaloskepsis",
"omphalotus",
"omphalus",
"omsk",
"onager",
"onagraceae",
"onanism",
"onanist",
"onchocerciasis",
"oncidium",
"oncogene",
"oncologist",
"oncology",
"oncoming",
"oncorhynchus",
"oncovin",
"ondaatje",
"ondatra",
"onega",
"oneida",
"oneirism",
"oneiromancer",
"oneiromancy",
"oneness",
"onerousness",
"onion",
"onionskin",
"oniscidae",
"oniscus",
"onlooker",
"onobrychis",
"onoclea",
"onomancer",
"onomancy",
"onomasticon",
"onomastics",
"onomatomania",
"onomatopoeia",
"onondaga",
"ononis",
"onopordon",
"onopordum",
"onosmodium",
"onrush",
"onsager",
"onset",
"onslaught",
"ontario",
"ontogenesis",
"ontogeny",
"ontology",
"onus",
"onychium",
"onychogalea",
"onycholysis",
"onychomys",
"onychophora",
"onychophoran",
"onychosis",
"onyx",
"onyxis",
"oocyte",
"oodles",
"oogenesis",
"oology",
"oolong",
"oomph",
"oomycetes",
"oophorectomy",
"oophoritis",
"oort",
"oosphere",
"oospore",
"ootid",
"ooze",
"oozing",
"opacification",
"opacity",
"opah",
"opal",
"opalescence",
"opaqueness",
"opcw",
"opec",
"opel",
"open",
"openbill",
"opener",
"openhandedness",
"opening",
"openness",
"openwork",
"opepe",
"opera",
"operagoer",
"operand",
"operation",
"operationalism",
"operations",
"operative",
"operator",
"operculum",
"operetta",
"operon",
"operoseness",
"opheodrys",
"ophidia",
"ophidian",
"ophidiidae",
"ophidism",
"ophiodon",
"ophiodontidae",
"ophioglossaceae",
"ophioglossales",
"ophioglossum",
"ophiolatry",
"ophiophagus",
"ophisaurus",
"ophiuchus",
"ophiurida",
"ophiuroidea",
"ophryon",
"ophrys",
"ophthalmectomy",
"ophthalmia",
"ophthalmitis",
"ophthalmologist",
"ophthalmology",
"ophthalmoplegia",
"ophthalmoscope",
"ophthalmoscopy",
"opiate",
"opiliones",
"opinion",
"opisthobranchia",
"opisthocomidae",
"opisthocomus",
"opisthorchiasis",
"opisthotonos",
"opium",
"opopanax",
"oporto",
"opossum",
"oppenheimer",
"opponent",
"opportuneness",
"opportunism",
"opportunist",
"opportunity",
"opposer",
"opposite",
"oppositeness",
"opposition",
"oppression",
"oppressiveness",
"oppressor",
"opprobrium",
"opsin",
"opsonin",
"opsonisation",
"opsonization",
"optative",
"optez",
"optic",
"optician",
"optics",
"optimisation",
"optimism",
"optimist",
"optimization",
"optimum",
"option",
"optometrist",
"optometry",
"opulence",
"opuntia",
"opuntiales",
"opus",
"orach",
"orache",
"oracle",
"oradexon",
"oral",
"oran",
"orang",
"orange",
"orangeade",
"orangeman",
"orangeness",
"orangery",
"orangewood",
"orangutan",
"orangutang",
"orasone",
"oration",
"orator",
"oratorio",
"oratory",
"orbignya",
"orbison",
"orbit",
"orbitale",
"orbiter",
"orca",
"orchard",
"orchestia",
"orchestiidae",
"orchestra",
"orchestration",
"orchestrator",
"orchid",
"orchidaceae",
"orchidales",
"orchidalgia",
"orchidectomy",
"orchiectomy",
"orchil",
"orchiopexy",
"orchis",
"orchitis",
"orchotomy",
"orcinus",
"orcus",
"orczy",
"ordainer",
"ordeal",
"order",
"orderer",
"ordering",
"orderliness",
"orderly",
"ordinal",
"ordinance",
"ordinand",
"ordinariness",
"ordinary",
"ordinate",
"ordination",
"ordnance",
"ordovician",
"ordure",
"oread",
"oreamnos",
"orectolobidae",
"orectolobus",
"oregano",
"oregon",
"oregonian",
"oreide",
"oreo",
"oreopteris",
"oreortyx",
"orestes",
"orff",
"organ",
"organdie",
"organdy",
"organelle",
"organic",
"organicism",
"organification",
"organisation",
"organiser",
"organism",
"organist",
"organization",
"organizer",
"organon",
"organophosphate",
"organs",
"organza",
"orgasm",
"orgy",
"oriel",
"orient",
"orientalism",
"orientalist",
"orientation",
"orifice",
"oriflamme",
"origami",
"origanum",
"origen",
"origin",
"original",
"originalism",
"originality",
"origination",
"originator",
"orinasal",
"orinase",
"orinoco",
"oriole",
"oriolidae",
"oriolus",
"orion",
"orison",
"orissa",
"orites",
"oriya",
"orizaba",
"orlando",
"orleanais",
"orleanism",
"orleanist",
"orleans",
"orlon",
"orlop",
"orly",
"ormandy",
"ormazd",
"ormer",
"ormolu",
"ormosia",
"ormuzd",
"ornament",
"ornamental",
"ornamentalism",
"ornamentalist",
"ornamentation",
"ornateness",
"orneriness",
"ornithine",
"ornithischia",
"ornithischian",
"ornithogalum",
"ornithologist",
"ornithology",
"ornithomimid",
"ornithomimida",
"ornithopod",
"ornithopoda",
"ornithopter",
"ornithorhynchus",
"ornithosis",
"orobanchaceae",
"orogeny",
"orography",
"oroide",
"orology",
"orono",
"orontium",
"oropharynx",
"orozco",
"orphan",
"orphanage",
"orphanhood",
"orphenadrine",
"orpheus",
"orphrey",
"orpiment",
"orpin",
"orpine",
"orpington",
"orrery",
"orris",
"orrisroot",
"ortalis",
"ortega",
"orthicon",
"orthilia",
"orthochorea",
"orthoclase",
"orthodontia",
"orthodontics",
"orthodontist",
"orthodonture",
"orthodoxy",
"orthoepist",
"orthoepy",
"orthogonality",
"orthography",
"orthomyxovirus",
"orthopaedics",
"orthopaedist",
"orthopedics",
"orthopedist",
"orthophosphate",
"orthopnea",
"orthopristis",
"orthopter",
"orthoptera",
"orthopteran",
"orthopteron",
"orthoptics",
"orthoptist",
"orthoscope",
"orthotomus",
"ortolan",
"ortygan",
"orudis",
"orumiyeh",
"oruvail",
"orwell",
"orycteropodidae",
"orycteropus",
"oryctolagus",
"oryx",
"oryza",
"oryzomys",
"oryzopsis",
"orzo",
"osage",
"osaka",
"osasco",
"osborne",
"oscan",
"oscar",
"oscheocele",
"oscheocoele",
"oscillation",
"oscillator",
"oscillogram",
"oscillograph",
"oscilloscope",
"oscine",
"oscines",
"oscitance",
"oscitancy",
"osculation",
"osculator",
"osha",
"osier",
"osiris",
"oslo",
"osmanli",
"osmanthus",
"osmeridae",
"osmerus",
"osmiridium",
"osmitrol",
"osmium",
"osmoreceptor",
"osmosis",
"osmund",
"osmundaceae",
"osprey",
"ossete",
"ossicle",
"ossiculum",
"ossification",
"ossuary",
"ostariophysi",
"osteichthyes",
"osteitis",
"ostensorium",
"ostentation",
"osteoarthritis",
"osteoblast",
"osteoblastoma",
"osteochondroma",
"osteoclasis",
"osteoclast",
"osteocyte",
"osteodystrophy",
"osteoglossidae",
"osteologer",
"osteologist",
"osteology",
"osteolysis",
"osteoma",
"osteomalacia",
"osteomyelitis",
"osteopath",
"osteopathist",
"osteopathy",
"osteopetrosis",
"osteophyte",
"osteoporosis",
"osteosarcoma",
"osteosclerosis",
"osteostracan",
"osteostraci",
"osteotomy",
"ostiarius",
"ostiary",
"ostinato",
"ostiole",
"ostler",
"ostomy",
"ostraciidae",
"ostracism",
"ostracod",
"ostracoda",
"ostracoderm",
"ostracodermi",
"ostrava",
"ostrea",
"ostreidae",
"ostrich",
"ostrogoth",
"ostrya",
"ostryopsis",
"ostwald",
"ostyak",
"oswald",
"otalgia",
"otaria",
"otariidae",
"othello",
"otherness",
"otherworld",
"otho",
"othonna",
"otides",
"otididae",
"otis",
"otitis",
"otoe",
"otoganglion",
"otolaryngology",
"otologist",
"otology",
"otoplasty",
"otorrhea",
"otosclerosis",
"otoscope",
"ottar",
"ottawa",
"otter",
"otterhound",
"ottoman",
"ottumwa",
"otus",
"ouachita",
"oubliette",
"ouguiya",
"ouija",
"oujda",
"ounce",
"ouranopithecus",
"ouranos",
"ouse",
"ousel",
"ouster",
"ousting",
"outage",
"outaouais",
"outback",
"outboard",
"outbreak",
"outbuilding",
"outburst",
"outcast",
"outcaste",
"outcome",
"outcrop",
"outcropping",
"outcry",
"outdoors",
"outdoorsman",
"outdoorswoman",
"outercourse",
"outerwear",
"outfall",
"outfield",
"outfielder",
"outfit",
"outfitter",
"outfitting",
"outflow",
"outgo",
"outgoer",
"outgrowth",
"outhouse",
"outing",
"outlander",
"outlandishness",
"outlaw",
"outlawry",
"outlay",
"outlet",
"outlier",
"outline",
"outlook",
"outpatient",
"outport",
"outpost",
"outpouring",
"output",
"outrage",
"outrageousness",
"outreach",
"outrider",
"outrigger",
"outset",
"outside",
"outsider",
"outsize",
"outskirt",
"outskirts",
"outsole",
"outspokenness",
"outstation",
"outstroke",
"outtake",
"outthrust",
"outturn",
"outwardness",
"outwork",
"ouzel",
"ouzo",
"oval",
"ovalbumin",
"ovalipes",
"ovariectomy",
"ovaritis",
"ovary",
"ovation",
"oven",
"ovenbird",
"ovenware",
"over",
"overabundance",
"overachievement",
"overachiever",
"overacting",
"overactivity",
"overage",
"overall",
"overanxiety",
"overappraisal",
"overbearingness",
"overbid",
"overbite",
"overburden",
"overcall",
"overcast",
"overcasting",
"overcharge",
"overclothes",
"overcoat",
"overcoating",
"overcomer",
"overconfidence",
"overcredulity",
"overcrossing",
"overdraft",
"overdrive",
"overeating",
"overemphasis",
"overestimate",
"overestimation",
"overexertion",
"overexposure",
"overfeeding",
"overflight",
"overflow",
"overgarment",
"overgrowth",
"overhang",
"overhaul",
"overhead",
"overheating",
"overindulgence",
"overkill",
"overlap",
"overlapping",
"overlay",
"overlayer",
"overlip",
"overload",
"overlook",
"overlord",
"overlordship",
"overmantel",
"overmuch",
"overmuchness",
"overnighter",
"overpass",
"overpayment",
"overplus",
"overpopulation",
"overpressure",
"overprint",
"overproduction",
"overprotection",
"overrating",
"overreaction",
"overreckoning",
"overrefinement",
"override",
"overrun",
"overseer",
"overshielding",
"overshoe",
"overshoot",
"oversight",
"overskirt",
"overspill",
"overstatement",
"overstrain",
"oversupply",
"overtaking",
"overthrow",
"overtime",
"overtolerance",
"overtone",
"overture",
"overturn",
"overuse",
"overutilisation",
"overutilization",
"overvaluation",
"overview",
"overweight",
"overwork",
"overworking",
"ovibos",
"ovid",
"oviduct",
"oviedo",
"ovimbundu",
"ovipositor",
"oviraptorid",
"ovis",
"ovocon",
"ovoflavin",
"ovoid",
"ovolo",
"ovotestis",
"ovral",
"ovrette",
"ovulation",
"ovule",
"ovulen",
"ovum",
"owen",
"owens",
"owensboro",
"owlclaws",
"owlet",
"owlt",
"owner",
"ownership",
"oxacillin",
"oxalacetate",
"oxalate",
"oxalidaceae",
"oxalis",
"oxaloacetate",
"oxandra",
"oxaprozin",
"oxazepam",
"oxbow",
"oxbridge",
"oxcart",
"oxen",
"oxeye",
"oxford",
"oxheart",
"oxidant",
"oxidase",
"oxidation",
"oxide",
"oxidisation",
"oxidiser",
"oxidization",
"oxidizer",
"oxidoreductase",
"oxidoreduction",
"oxime",
"oximeter",
"oxlip",
"oxonian",
"oxtail",
"oxtant",
"oxtongue",
"oxyacetylene",
"oxyacid",
"oxybelis",
"oxybenzene",
"oxycephaly",
"oxydendrum",
"oxygen",
"oxygenase",
"oxygenation",
"oxyhaemoglobin",
"oxyhemoglobin",
"oxylebius",
"oxymoron",
"oxyopia",
"oxyphenbutazone",
"oxytetracycline",
"oxytocic",
"oxytocin",
"oxytone",
"oxytropis",
"oxyura",
"oxyuranus",
"oxyuridae",
"oyabun",
"oyster",
"oystercatcher",
"oysterfish",
"ozaena",
"ozarks",
"ozawa",
"ozena",
"ozocerite",
"ozokerite",
"ozone",
"ozonide",
"ozonium",
"ozonosphere",
"ozothamnus",
"paba",
"pabir",
"pablum",
"pabulum",
"paca",
"pace",
"pacemaker",
"pacer",
"pacesetter",
"pacha",
"pachinko",
"pachisi",
"pachouli",
"pachuco",
"pachycephala",
"pachycheilia",
"pachyderm",
"pachyderma",
"pachyrhizus",
"pachysandra",
"pachytene",
"pacific",
"pacification",
"pacificism",
"pacificist",
"pacifier",
"pacifism",
"pacifist",
"pacing",
"pack",
"package",
"packaging",
"packer",
"packera",
"packet",
"packhorse",
"packing",
"packinghouse",
"packman",
"packrat",
"packsack",
"packsaddle",
"packthread",
"pact",
"padauk",
"padda",
"padder",
"padding",
"paddle",
"paddlefish",
"paddler",
"paddlewheel",
"paddock",
"paddy",
"paddymelon",
"pademelon",
"paderewski",
"padlock",
"padouk",
"padova",
"padre",
"padrone",
"padua",
"paducah",
"paean",
"paederast",
"paederasty",
"paediatrician",
"paediatrics",
"paedophile",
"paedophilia",
"paella",
"paeonia",
"paeoniaceae",
"paeony",
"pagad",
"pagan",
"paganini",
"paganism",
"page",
"pageant",
"pageantry",
"pageboy",
"pagellus",
"pager",
"paget",
"pagination",
"paging",
"pagoda",
"pagophila",
"pagophilus",
"pagrus",
"paguridae",
"pagurus",
"pahang",
"pahautea",
"pahlavi",
"pahlevi",
"pahoehoe",
"paige",
"paigle",
"pail",
"pailful",
"paillasse",
"pain",
"paine",
"painfulness",
"painkiller",
"pains",
"painstakingness",
"paint",
"paintball",
"paintbox",
"paintbrush",
"painter",
"painting",
"pair",
"pairing",
"paisa",
"paisley",
"paiute",
"paiwanic",
"pajama",
"pakchoi",
"pakistan",
"pakistani",
"palace",
"paladin",
"palaeencephalon",
"palaemon",
"palaemonidae",
"palaeobiology",
"palaeobotany",
"palaeoecology",
"palaeogeography",
"palaeogeology",
"palaeolithic",
"palaeology",
"palaeontologist",
"palaeontology",
"palaeopathology",
"palaeozoology",
"palaestra",
"palaetiology",
"palaic",
"palankeen",
"palanquin",
"palaquium",
"palas",
"palatability",
"palatableness",
"palatal",
"palate",
"palatinate",
"palatine",
"palau",
"palaver",
"pale",
"paleacrita",
"paleencephalon",
"paleness",
"paleobiology",
"paleobotany",
"paleocene",
"paleocerebellum",
"paleocortex",
"paleodendrology",
"paleoecology",
"paleoencephalon",
"paleogeography",
"paleogeology",
"paleographer",
"paleographist",
"paleography",
"paleolith",
"paleolithic",
"paleology",
"paleomammalogy",
"paleontologist",
"paleontology",
"paleopathology",
"paleornithology",
"paleostriatum",
"paleozoic",
"paleozoology",
"palermo",
"palestine",
"palestinian",
"palestra",
"palestrina",
"paletiology",
"palette",
"palfrey",
"palgrave",
"pali",
"palilalia",
"palimony",
"palimpsest",
"palindrome",
"paling",
"palingenesis",
"palinuridae",
"palinurus",
"palisade",
"paliurus",
"pall",
"palladio",
"palladium",
"pallas",
"pallasite",
"pallbearer",
"pallet",
"pallette",
"palliasse",
"palliation",
"palliative",
"pallidity",
"pallidness",
"pallidum",
"pallium",
"pallone",
"pallor",
"palm",
"palmaceae",
"palmae",
"palmales",
"palmature",
"palmer",
"palmetto",
"palmist",
"palmister",
"palmistry",
"palmitin",
"palmyra",
"palometa",
"palomino",
"palooka",
"paloverde",
"palpability",
"palpation",
"palpebra",
"palpebration",
"palpitation",
"palsgrave",
"palsy",
"paltering",
"paltriness",
"pamelor",
"pamlico",
"pampas",
"pamperer",
"pampering",
"pamphlet",
"pamphleteer",
"panacea",
"panache",
"panadol",
"panama",
"panamanian",
"panamica",
"panamiga",
"panatela",
"panax",
"pancake",
"pancarditis",
"panchayat",
"panchayet",
"pancreas",
"pancreatectomy",
"pancreatin",
"pancreatitis",
"pancytopenia",
"panda",
"pandanaceae",
"pandanales",
"pandanus",
"pandar",
"pandeism",
"pandemic",
"pandemonium",
"pander",
"panderer",
"pandiculation",
"pandion",
"pandionidae",
"pandora",
"pandowdy",
"pane",
"panegyric",
"panegyrist",
"panel",
"paneling",
"panelist",
"panelling",
"panellist",
"panencephalitis",
"panenthesism",
"panetela",
"panetella",
"panfish",
"pang",
"panga",
"pangaea",
"pangea",
"pangloss",
"pangolin",
"panhandle",
"panhandler",
"panhysterectomy",
"panic",
"panicle",
"panicum",
"panini",
"panipat",
"panjabi",
"panjandrum",
"pannier",
"pannikin",
"panocha",
"panoche",
"panofsky",
"panonychus",
"panoply",
"panopticon",
"panorama",
"panorpidae",
"panpipe",
"pansa",
"pansexual",
"pansinusitis",
"pansy",
"pant",
"pantaloon",
"pantechnicon",
"pantheism",
"pantheist",
"pantheon",
"panther",
"panthera",
"pantie",
"pantile",
"panting",
"panto",
"pantograph",
"pantomime",
"pantomimer",
"pantomimist",
"pantothen",
"pantotheria",
"pantry",
"pantryman",
"pants",
"pantsuit",
"panty",
"pantyhose",
"pantywaist",
"panzer",
"papa",
"papacy",
"papaia",
"papain",
"paparazzo",
"papaver",
"papaveraceae",
"papaverales",
"papaverine",
"papaw",
"papaya",
"papeete",
"paper",
"paperback",
"paperboard",
"paperboy",
"paperclip",
"paperer",
"paperhanger",
"paperhanging",
"papering",
"paperknife",
"papermaking",
"papers",
"paperweight",
"paperwork",
"paphiopedilum",
"papilionaceae",
"papilionoideae",
"papilla",
"papilledema",
"papilloma",
"papillon",
"papio",
"papism",
"papist",
"papoose",
"papooseroot",
"papovavirus",
"pappa",
"pappoose",
"pappus",
"paprika",
"paprilus",
"papua",
"papuan",
"papule",
"papulovesicle",
"papyrus",
"para",
"parable",
"parabola",
"paraboloid",
"paracelsus",
"paracentesis",
"paracheirodon",
"parachute",
"parachuter",
"parachuting",
"parachutist",
"paraclete",
"paracosm",
"parade",
"parader",
"paradiddle",
"paradigm",
"paradisaeidae",
"paradise",
"paradox",
"paradoxurus",
"paraesthesia",
"paraffin",
"parafovea",
"paragliding",
"paragon",
"paragonite",
"paragraph",
"paragrapher",
"paraguay",
"paraguayan",
"parakeet",
"paralanguage",
"paraldehyde",
"paralegal",
"paraleipsis",
"paralepsis",
"paralichthys",
"paralipomenon",
"paralipsis",
"paralithodes",
"parallax",
"parallel",
"parallelepiped",
"parallelism",
"parallelogram",
"parallelopiped",
"paralogism",
"paralysis",
"paralytic",
"paramagnet",
"paramagnetism",
"paramaribo",
"paramecia",
"paramecium",
"paramedic",
"paramedical",
"parameter",
"parametritis",
"paramilitary",
"paramnesia",
"paramountcy",
"paramour",
"paramyxovirus",
"parana",
"parang",
"paranoia",
"paranoiac",
"paranoid",
"paranthias",
"paranthropus",
"paraparesis",
"parapet",
"paraph",
"paraphernalia",
"paraphilia",
"paraphrase",
"paraphrasis",
"paraphrenia",
"paraphysis",
"paraplegia",
"paraplegic",
"parapodium",
"parapraxis",
"parapsychology",
"paraquat",
"paraquet",
"parasail",
"parasailing",
"parascalops",
"parashurama",
"parasitaemia",
"parasitaxus",
"parasite",
"parasitemia",
"parasitism",
"parasol",
"parasympathetic",
"parathelypteris",
"parathion",
"parathormone",
"parathyroid",
"paratrooper",
"paratroops",
"paratyphoid",
"parazoa",
"parazoan",
"parcae",
"parcel",
"parceling",
"parcellation",
"parcelling",
"parcheesi",
"parchesi",
"parchisi",
"parchment",
"pardner",
"pardon",
"pardoner",
"paregmenon",
"paregoric",
"parenchyma",
"parent",
"parentage",
"parenthesis",
"parenthetical",
"parenthood",
"parer",
"paresis",
"paresthesia",
"paretic",
"pareto",
"parfait",
"parget",
"pargeting",
"pargetry",
"pargetting",
"parhelion",
"pariah",
"paridae",
"paries",
"parietales",
"parietaria",
"parimutuel",
"paring",
"paris",
"parish",
"parishioner",
"parisian",
"parisienne",
"parisology",
"parity",
"parjanya",
"parji",
"park",
"parka",
"parker",
"parkeriaceae",
"parkersburg",
"parkia",
"parking",
"parkinson",
"parkinsonia",
"parkinsonism",
"parkland",
"parks",
"parkway",
"parlance",
"parlay",
"parley",
"parliament",
"parliamentarian",
"parlor",
"parlormaid",
"parlour",
"parlourmaid",
"parmelia",
"parmeliaceae",
"parmenides",
"parmesan",
"parnahiba",
"parnaiba",
"parnassia",
"parnassus",
"parnell",
"parochetus",
"parochialism",
"parodist",
"parody",
"parole",
"parolee",
"paronomasia",
"paronychia",
"paronym",
"parophrys",
"paroquet",
"parosamia",
"parotitis",
"parousia",
"paroxetime",
"paroxysm",
"paroxytone",
"parquet",
"parqueterie",
"parquetry",
"parr",
"parrakeet",
"parricide",
"parrish",
"parroket",
"parroquet",
"parrot",
"parrotfish",
"parrotia",
"parrotiopsis",
"parry",
"parsec",
"parsee",
"parseeism",
"parser",
"parsi",
"parsiism",
"parsimony",
"parsley",
"parsnip",
"parson",
"parsonage",
"parsons",
"part",
"partaker",
"parterre",
"parthenium",
"parthenocarpy",
"parthenocissus",
"parthenogenesis",
"parthenogeny",
"parthenon",
"parthenote",
"parthia",
"parthian",
"partial",
"partiality",
"partialness",
"participant",
"participation",
"participial",
"participle",
"particle",
"particular",
"particularism",
"particularity",
"particulate",
"parting",
"partisan",
"partisanship",
"partita",
"partition",
"partitioning",
"partitionist",
"partitive",
"partizan",
"partner",
"partnership",
"partridge",
"partridgeberry",
"parts",
"partsong",
"parturiency",
"parturition",
"party",
"partygoer",
"parula",
"parulidae",
"parus",
"parvati",
"parvenu",
"parvis",
"parvo",
"parvovirus",
"pasadena",
"pasang",
"pascal",
"pasch",
"pascha",
"paseo",
"pasha",
"pashto",
"pashtoon",
"pashtu",
"pashtun",
"pasigraphy",
"pasiphae",
"paspalum",
"pasqueflower",
"pasquinade",
"pass",
"passado",
"passage",
"passageway",
"passamaquody",
"passbook",
"passel",
"passementerie",
"passenger",
"passer",
"passerby",
"passeres",
"passeridae",
"passeriformes",
"passerina",
"passerine",
"passero",
"passiflora",
"passifloraceae",
"passing",
"passion",
"passionateness",
"passionflower",
"passive",
"passiveness",
"passivism",
"passivity",
"passkey",
"passover",
"passport",
"password",
"past",
"pasta",
"paste",
"pasteboard",
"pastel",
"paster",
"pastern",
"pasternak",
"pasteur",
"pasteurellosis",
"pasteurisation",
"pasteurization",
"pastiche",
"pastil",
"pastille",
"pastime",
"pastinaca",
"pastis",
"pastness",
"pasto",
"pastor",
"pastoral",
"pastorale",
"pastorate",
"pastorship",
"pastrami",
"pastry",
"pasturage",
"pasture",
"pastureland",
"pasty",
"pataca",
"patagonia",
"patas",
"patavium",
"patch",
"patchboard",
"patchcord",
"patchiness",
"patching",
"patchouli",
"patchouly",
"patchwork",
"pate",
"patella",
"patellidae",
"patency",
"patent",
"patentee",
"pater",
"paterfamilias",
"paternalism",
"paternity",
"paternoster",
"paterson",
"path",
"pathan",
"pathfinder",
"pathogen",
"pathogenesis",
"pathologist",
"pathology",
"pathos",
"pathway",
"patience",
"patient",
"patina",
"patio",
"patisserie",
"patka",
"patness",
"patois",
"paton",
"patrai",
"patras",
"patrial",
"patriarch",
"patriarchate",
"patriarchy",
"patrician",
"patricide",
"patrick",
"patrikin",
"patrilineage",
"patrimony",
"patriot",
"patrioteer",
"patriotism",
"patrisib",
"patristics",
"patroclus",
"patrol",
"patroller",
"patrolman",
"patrology",
"patron",
"patronage",
"patroness",
"patronne",
"patronym",
"patronymic",
"patsy",
"patten",
"patter",
"pattern",
"patternmaker",
"patty",
"patwin",
"patzer",
"paucity",
"paul",
"pauli",
"pauling",
"paunch",
"paunchiness",
"pauper",
"pauperisation",
"pauperism",
"pauperization",
"pauropoda",
"pause",
"pavage",
"pavan",
"pavane",
"pavarotti",
"pave",
"pavement",
"pavilion",
"paving",
"pavior",
"paviour",
"pavis",
"pavise",
"pavlov",
"pavlova",
"pavo",
"pavonia",
"pawer",
"pawl",
"pawn",
"pawnbroker",
"pawnee",
"pawnshop",
"pawpaw",
"paxil",
"paxto",
"paxton",
"payable",
"payables",
"payback",
"paycheck",
"payday",
"paye",
"payee",
"payena",
"payer",
"paygrade",
"payload",
"paymaster",
"payment",
"paynim",
"payoff",
"payola",
"payroll",
"paysheet",
"payslip",
"pbit",
"pdflp",
"peabody",
"peace",
"peaceableness",
"peacefulness",
"peacekeeper",
"peacekeeping",
"peacemaker",
"peacenik",
"peacetime",
"peach",
"peachick",
"peachwood",
"peacoat",
"peacock",
"peafowl",
"peag",
"peahen",
"peak",
"peal",
"pealing",
"pean",
"peanut",
"peanuts",
"pear",
"pearl",
"pearler",
"pearlfish",
"pearlite",
"pearlweed",
"pearlwort",
"pearly",
"pearmain",
"peary",
"peasant",
"peasanthood",
"peasantry",
"peasecod",
"peat",
"peavey",
"peavy",
"peba",
"pebble",
"pebibit",
"pebibyte",
"pecan",
"peccadillo",
"peccary",
"peck",
"pecker",
"peckerwood",
"pecopteris",
"pecos",
"pecs",
"pectin",
"pectinibranchia",
"pectinidae",
"pectoral",
"pectoralis",
"pectus",
"peculation",
"peculator",
"peculiarity",
"pedagog",
"pedagogics",
"pedagogue",
"pedagogy",
"pedal",
"pedaler",
"pedaliaceae",
"pedaller",
"pedant",
"pedantry",
"peddler",
"peddling",
"pederast",
"pederasty",
"pedesis",
"pedestal",
"pedestrian",
"pediamycin",
"pediapred",
"pediatrician",
"pediatrics",
"pediatrist",
"pedicab",
"pedicel",
"pedicle",
"pediculati",
"pediculicide",
"pediculidae",
"pediculosis",
"pediculus",
"pedicure",
"pedigree",
"pedilanthus",
"pediment",
"pediocactus",
"pedioecetes",
"pedionomus",
"pedipalpi",
"pedlar",
"pedodontist",
"pedology",
"pedometer",
"pedophile",
"pedophilia",
"peduncle",
"pedwood",
"peeing",
"peek",
"peekaboo",
"peel",
"peeler",
"peeling",
"peen",
"peep",
"peeper",
"peephole",
"peepshow",
"peepul",
"peer",
"peerage",
"peeress",
"peeve",
"peevishness",
"peewee",
"peewit",
"pegasus",
"pegboard",
"pegleg",
"pegmatite",
"pehlevi",
"peignoir",
"peiping",
"peirce",
"peireskia",
"pekan",
"peke",
"pekinese",
"peking",
"pekingese",
"pekoe",
"pelage",
"pelagianism",
"pelagius",
"pelargonium",
"pelecanidae",
"pelecaniformes",
"pelecanoididae",
"pelecanus",
"pelecypod",
"peleus",
"pelew",
"pelf",
"pelham",
"pelican",
"peliosis",
"pelisse",
"pellaea",
"pellagra",
"pellet",
"pellicle",
"pellicularia",
"pellitory",
"pellucidity",
"pellucidness",
"pelmet",
"pelobatidae",
"peloponnese",
"peloponnesus",
"pelota",
"pelt",
"peltandra",
"pelter",
"pelting",
"peltiphyllum",
"peludo",
"pelvimeter",
"pelvimetry",
"pelvis",
"pelycosaur",
"pelycosauria",
"pembroke",
"pemican",
"pemmican",
"pempheridae",
"pemphigus",
"penalisation",
"penalization",
"penalty",
"penance",
"penang",
"penchant",
"pencil",
"pendant",
"pendent",
"pendragon",
"pendulum",
"peneidae",
"penelope",
"peneplain",
"peneplane",
"penetrability",
"penetralium",
"penetration",
"penetrator",
"peneus",
"pengo",
"penguin",
"penicillamine",
"penicillin",
"penicillinase",
"penicillium",
"peninsula",
"penis",
"penitence",
"penitent",
"penitentiary",
"penknife",
"penlight",
"penman",
"penmanship",
"penn",
"pennant",
"pennatula",
"pennatulidae",
"penne",
"penni",
"pennilessness",
"pennines",
"penning",
"pennisetum",
"pennon",
"pennoncel",
"pennoncelle",
"pennsylvania",
"pennsylvanian",
"penny",
"pennycress",
"pennyroyal",
"pennyweight",
"pennywhistle",
"pennyworth",
"penobscot",
"penoche",
"penologist",
"penology",
"penoncel",
"penpusher",
"pensacola",
"pension",
"pensionary",
"pensioner",
"pensiveness",
"penstemon",
"penstock",
"pentacle",
"pentad",
"pentaerythritol",
"pentagon",
"pentagram",
"pentahedron",
"pentail",
"pentameter",
"pentangle",
"pentastomid",
"pentastomida",
"pentateuch",
"pentathlete",
"pentathlon",
"pentatone",
"pentazocine",
"pentecost",
"pentecostal",
"pentecostalism",
"pentecostalist",
"penthouse",
"pentimento",
"pentlandite",
"pentobarbital",
"pentode",
"pentose",
"pentothal",
"pentoxide",
"pentoxifylline",
"penuche",
"penuchle",
"penult",
"penultima",
"penultimate",
"penumbra",
"penuriousness",
"penury",
"penutian",
"peon",
"peonage",
"peony",
"people",
"peoples",
"peoria",
"pepcid",
"peperomia",
"pepin",
"peplos",
"peplum",
"peplus",
"pepper",
"peppercorn",
"pepperidge",
"pepperiness",
"peppermint",
"pepperoni",
"pepperwood",
"pepperwort",
"peppiness",
"pepsi",
"pepsin",
"pepsinogen",
"peptidase",
"peptide",
"peptisation",
"peptization",
"peptone",
"pepys",
"peradventure",
"perak",
"perambulation",
"perambulator",
"peramelidae",
"perca",
"percale",
"perceiver",
"percent",
"percentage",
"percentile",
"percept",
"perceptibility",
"perception",
"perceptiveness",
"perceptivity",
"perch",
"percher",
"percheron",
"perchlorate",
"perchloride",
"percidae",
"perciformes",
"percina",
"percipient",
"percoid",
"percoidea",
"percoidean",
"percolate",
"percolation",
"percolator",
"percomorphi",
"percophidae",
"percussion",
"percussionist",
"percussor",
"percy",
"perdicidae",
"perdicinae",
"perdition",
"perdix",
"perdurability",
"peregrination",
"peregrine",
"perejil",
"perennation",
"perennial",
"pereskia",
"perestroika",
"perfect",
"perfecta",
"perfecter",
"perfectibility",
"perfection",
"perfectionism",
"perfectionist",
"perfective",
"perfidiousness",
"perfidy",
"perfluorocarbon",
"perforation",
"performance",
"performer",
"performing",
"perfume",
"perfumer",
"perfumery",
"perfusion",
"pergamum",
"pergola",
"peri",
"periactin",
"perianth",
"periapsis",
"periarteritis",
"pericallis",
"pericarditis",
"pericardium",
"pericarp",
"periclase",
"pericles",
"peridinian",
"peridiniidae",
"peridinium",
"peridium",
"peridot",
"peridotite",
"perigee",
"perigon",
"perigone",
"perigonium",
"perihelion",
"perijove",
"peril",
"perilla",
"perilousness",
"perilune",
"perilymph",
"perimeter",
"perimysium",
"perinatologist",
"perinatology",
"perineotomy",
"perineum",
"perineurium",
"period",
"periodical",
"periodicity",
"periodontia",
"periodontics",
"periodontist",
"periodontitis",
"periophthalmus",
"periosteum",
"peripatetic",
"peripateticism",
"peripatidae",
"peripatopsidae",
"peripatopsis",
"peripatus",
"peripeteia",
"peripetia",
"peripety",
"peripheral",
"periphery",
"periphrasis",
"periplaneta",
"periploca",
"periscope",
"periselene",
"perishability",
"perishable",
"perishableness",
"perisher",
"perisoreus",
"perisperm",
"perissodactyl",
"perissodactyla",
"peristalsis",
"peristediinae",
"peristedion",
"peristome",
"peristyle",
"perithecium",
"perithelium",
"peritoneum",
"peritonitis",
"peritrate",
"periwig",
"periwinkle",
"perjurer",
"perjury",
"perk",
"perkiness",
"perleche",
"perlis",
"perm",
"permafrost",
"permalloy",
"permanence",
"permanency",
"permanent",
"permanganate",
"permeability",
"permeableness",
"permeation",
"permian",
"permic",
"permissibility",
"permission",
"permissiveness",
"permit",
"permutability",
"permutableness",
"permutation",
"pernambuco",
"perniciousness",
"pernio",
"pernis",
"pernod",
"perodicticus",
"perognathus",
"peromyscus",
"peron",
"peroneus",
"peronospora",
"peronosporaceae",
"peronosporales",
"peroration",
"peroxidase",
"peroxide",
"perpendicular",
"perpetration",
"perpetrator",
"perpetuation",
"perpetuity",
"perphenazine",
"perplexity",
"perquisite",
"perry",
"persea",
"persecution",
"persecutor",
"persephone",
"persepolis",
"perseus",
"perseverance",
"perseveration",
"pershing",
"persia",
"persian",
"persiflage",
"persimmon",
"persistence",
"persistency",
"person",
"persona",
"personableness",
"personage",
"personal",
"personality",
"personalty",
"personation",
"personhood",
"personification",
"personnel",
"persoonia",
"perspective",
"perspex",
"perspicacity",
"perspicuity",
"perspicuousness",
"perspiration",
"perspirer",
"persuader",
"persuasion",
"persuasiveness",
"pertainym",
"perth",
"pertinacity",
"pertinence",
"pertinency",
"pertness",
"perturbation",
"pertusaria",
"pertusariaceae",
"pertussis",
"peru",
"peruke",
"perusal",
"perusing",
"perutz",
"peruvian",
"pervaporation",
"pervasion",
"pervasiveness",
"perverseness",
"perversion",
"perversity",
"pervert",
"perviousness",
"pesach",
"pesah",
"pesantran",
"pesantren",
"peseta",
"pesewa",
"peshawar",
"peshmerga",
"peso",
"pessary",
"pessimism",
"pessimist",
"pest",
"pesterer",
"pesthole",
"pesthouse",
"pesticide",
"pestilence",
"pestis",
"pestle",
"pesto",
"petabit",
"petabyte",
"petal",
"petard",
"petasites",
"petaurista",
"petauristidae",
"petaurus",
"petchary",
"petcock",
"petechia",
"peter",
"peterburg",
"petersburg",
"petfood",
"petiole",
"petiolule",
"petite",
"petiteness",
"petitio",
"petition",
"petitioner",
"petrarca",
"petrarch",
"petrel",
"petrifaction",
"petrification",
"petrissage",
"petrochemical",
"petrocoptis",
"petrogale",
"petroglyph",
"petrograd",
"petrol",
"petrolatum",
"petroleum",
"petrology",
"petromyzon",
"petromyzontidae",
"petronius",
"petroselinum",
"petter",
"petteria",
"petticoat",
"pettifogger",
"pettifoggery",
"pettiness",
"petting",
"pettishness",
"petty",
"petulance",
"petunia",
"peul",
"pewee",
"pewit",
"pewter",
"peyote",
"peziza",
"pezizaceae",
"pezizales",
"pezophaps",
"pfalz",
"pfannkuchen",
"pfennig",
"pflp",
"phacelia",
"phacochoerus",
"phaeophyceae",
"phaeophyta",
"phaethon",
"phaethontidae",
"phaeton",
"phage",
"phagocyte",
"phagocytosis",
"phagun",
"phaius",
"phalacrocorax",
"phalacrosis",
"phalaenopsis",
"phalaenoptilus",
"phalanger",
"phalangeridae",
"phalangida",
"phalangiidae",
"phalangist",
"phalangitis",
"phalangium",
"phalanx",
"phalaris",
"phalarope",
"phalaropidae",
"phalaropus",
"phalguna",
"phallaceae",
"phallales",
"phalloplasty",
"phallus",
"phalsa",
"phanerogam",
"phanerogamae",
"phaneromania",
"phanerozoic",
"phantasm",
"phantasma",
"phantasmagoria",
"phantasy",
"phantom",
"pharaoh",
"pharisee",
"pharma",
"pharmaceutic",
"pharmaceutical",
"pharmaceutics",
"pharmacist",
"pharmacologist",
"pharmacology",
"pharmacopeia",
"pharmacopoeia",
"pharmacy",
"pharomacrus",
"pharos",
"pharsalus",
"pharyngeal",
"pharyngitis",
"pharynx",
"phascogale",
"phascolarctos",
"phase",
"phaseolus",
"phasianid",
"phasianidae",
"phasianus",
"phasmatidae",
"phasmatodea",
"phasmid",
"phasmida",
"phasmidae",
"phasmidia",
"pheasant",
"phegopteris",
"pheidias",
"phellem",
"phellodendron",
"phenacetin",
"phenacomys",
"phenaphen",
"phenazopyridine",
"phencyclidine",
"phenelzine",
"phenergan",
"phenicia",
"pheniramine",
"phenobarbital",
"phenobarbitone",
"phenol",
"phenolic",
"phenolphthalein",
"phenomenology",
"phenomenon",
"phenoplast",
"phenothiazine",
"phenotype",
"phensuximide",
"phentolamine",
"phenylacetamide",
"phenylalanine",
"phenylamine",
"phenylbutazone",
"phenylephrine",
"phenylethylene",
"phenylketonuria",
"phenytoin",
"pheresis",
"pheromone",
"phial",
"phidias",
"philadelphaceae",
"philadelphia",
"philadelphus",
"philaenus",
"philanderer",
"philanthropist",
"philanthropy",
"philatelist",
"philately",
"philemon",
"philharmonic",
"philhellene",
"philhellenism",
"philhellenist",
"philia",
"philip",
"philippi",
"philippian",
"philippians",
"philippic",
"philippine",
"philippines",
"philippopolis",
"philistia",
"philistine",
"philistinism",
"phillidae",
"phillipsite",
"phillyrea",
"philodendron",
"philogyny",
"philohela",
"philologist",
"philologue",
"philology",
"philomachus",
"philomath",
"philophylla",
"philosopher",
"philosophiser",
"philosophizer",
"philosophizing",
"philosophy",
"philter",
"philtre",
"phimosis",
"phintias",
"phiz",
"phlebectomy",
"phlebitis",
"phlebodium",
"phlebogram",
"phlebotomist",
"phlebotomus",
"phlebotomy",
"phlegm",
"phleum",
"phloem",
"phlogiston",
"phlogopite",
"phlomis",
"phlox",
"phobia",
"phobophobia",
"phobos",
"phoca",
"phocidae",
"phocoena",
"phocomelia",
"phoebe",
"phoebus",
"phoenicia",
"phoenician",
"phoenicophorium",
"phoeniculidae",
"phoeniculus",
"phoenicurus",
"phoenix",
"pholadidae",
"pholas",
"pholidae",
"pholidota",
"pholiota",
"pholis",
"pholistoma",
"phon",
"phonation",
"phone",
"phonebook",
"phoneme",
"phonemics",
"phoner",
"phonetician",
"phonetics",
"phoney",
"phonics",
"phonogram",
"phonograph",
"phonologist",
"phonology",
"phonophobia",
"phony",
"phoradendron",
"phoronid",
"phoronida",
"phoronidea",
"phosgene",
"phosphatase",
"phosphate",
"phosphine",
"phosphocreatine",
"phospholipid",
"phosphoprotein",
"phosphor",
"phosphorescence",
"phosphorus",
"phot",
"photalgia",
"photinia",
"photius",
"photo",
"photoblepharon",
"photocathode",
"photocell",
"photochemistry",
"photocoagulator",
"photoconduction",
"photocopier",
"photocopy",
"photoelectron",
"photoemission",
"photoengraving",
"photoflash",
"photoflood",
"photograph",
"photographer",
"photography",
"photogravure",
"photojournalism",
"photojournalist",
"photolithograph",
"photomechanics",
"photometer",
"photometrician",
"photometrist",
"photometry",
"photomicrograph",
"photomontage",
"photomosaic",
"photon",
"photophobia",
"photopigment",
"photoretinitis",
"photosphere",
"photostat",
"photosynthesis",
"phototherapy",
"phototropism",
"phoxinus",
"phragmacone",
"phragmipedium",
"phragmites",
"phragmocone",
"phrase",
"phraseology",
"phrasing",
"phratry",
"phrenitis",
"phrenologist",
"phrenology",
"phrontistery",
"phrygia",
"phrygian",
"phrynosoma",
"phthiriidae",
"phthirius",
"phthirus",
"phthisis",
"phthorimaea",
"phycobilin",
"phycocyanin",
"phycoerythrin",
"phycology",
"phycomycetes",
"phycomycosis",
"phylactery",
"phyle",
"phyllidae",
"phyllitis",
"phyllium",
"phyllo",
"phylloclad",
"phyllocladaceae",
"phylloclade",
"phyllocladus",
"phyllode",
"phyllodoce",
"phylloporus",
"phylloquinone",
"phyllorhynchus",
"phylloscopus",
"phyllostachys",
"phyllostomidae",
"phyllostomus",
"phylloxera",
"phylloxeridae",
"phylogenesis",
"phylogeny",
"phylum",
"physa",
"physalia",
"physalis",
"physaria",
"physeter",
"physeteridae",
"physiatrics",
"physic",
"physicalism",
"physicality",
"physicalness",
"physician",
"physicist",
"physics",
"physidae",
"physiognomy",
"physiography",
"physiologist",
"physiology",
"physiotherapist",
"physiotherapy",
"physique",
"physostegia",
"physostigma",
"physostigmine",
"phytelephas",
"phytochemical",
"phytochemist",
"phytochemistry",
"phytohormone",
"phytolacca",
"phytolaccaceae",
"phytologist",
"phytology",
"phytomastigina",
"phytonadione",
"phytophthora",
"phytoplankton",
"phytotherapy",
"phytotoxin",
"piaf",
"piaffe",
"piaget",
"pianism",
"pianissimo",
"pianist",
"piano",
"pianoforte",
"pianola",
"piaster",
"piastre",
"piazza",
"pibgorn",
"pibit",
"pibroch",
"pica",
"picador",
"picaninny",
"picardie",
"picardy",
"picariae",
"picasso",
"piccalilli",
"piccaninny",
"piccolo",
"picea",
"pichi",
"pichiciago",
"pichiciego",
"picidae",
"piciformes",
"pick",
"pickaninny",
"pickax",
"pickaxe",
"pickelhaube",
"picker",
"pickerel",
"pickerelweed",
"pickeringia",
"picket",
"pickett",
"pickford",
"picking",
"pickings",
"pickle",
"picklepuss",
"picknicker",
"pickpocket",
"pickup",
"picnic",
"picnicker",
"picofarad",
"picoides",
"picometer",
"picometre",
"picornavirus",
"picosecond",
"picot",
"picovolt",
"picrasma",
"picris",
"pictograph",
"pictor",
"pictorial",
"picture",
"picturesqueness",
"picturing",
"picul",
"piculet",
"picumnus",
"picus",
"piddle",
"piddock",
"pidgin",
"pidlimdi",
"piece",
"piecework",
"piedmont",
"piemonte",
"pieplant",
"pier",
"pierce",
"pierid",
"pieridae",
"pieris",
"pierre",
"pierrot",
"pieta",
"pietism",
"piety",
"piezometer",
"piffle",
"pigboat",
"pigeon",
"pigeonhole",
"pigeonholing",
"pigfish",
"piggery",
"piggishness",
"piggy",
"piggyback",
"pigheadedness",
"piglet",
"pigman",
"pigment",
"pigmentation",
"pigmy",
"pignolia",
"pignut",
"pigpen",
"pigskin",
"pigsticking",
"pigsty",
"pigswill",
"pigtail",
"pigwash",
"pigweed",
"pika",
"pike",
"pikeblenny",
"pikestaff",
"pilaf",
"pilaff",
"pilaster",
"pilate",
"pilau",
"pilaw",
"pilchard",
"pile",
"pilea",
"piles",
"pileup",
"pileus",
"pilewort",
"pilferage",
"pilferer",
"pilgrim",
"pilgrimage",
"piling",
"pill",
"pillage",
"pillager",
"pillaging",
"pillar",
"pillbox",
"pillion",
"pillock",
"pillory",
"pillow",
"pillowcase",
"pillwort",
"pilocarpine",
"pilosella",
"pilosity",
"pilot",
"pilotage",
"pilotfish",
"pilothouse",
"piloting",
"pilsen",
"pilsener",
"pilsner",
"pilularia",
"pilus",
"pima",
"pimenta",
"pimento",
"pimiento",
"pimlico",
"pimozide",
"pimp",
"pimpernel",
"pimpinella",
"pimple",
"pinaceae",
"pinafore",
"pinata",
"pinatubo",
"pinball",
"pincer",
"pinch",
"pinchbeck",
"pinche",
"pinchgut",
"pinckneya",
"pinctada",
"pincus",
"pincushion",
"pindar",
"pindaric",
"pindolol",
"pine",
"pinealoma",
"pineapple",
"pinecone",
"pinesap",
"pinetum",
"pineus",
"pineweed",
"pinfish",
"pinfold",
"ping",
"pinger",
"pinguecula",
"pinguicula",
"pinguinus",
"pinhead",
"pinhole",
"pinicola",
"pining",
"pinion",
"pinite",
"pink",
"pinkeye",
"pinkie",
"pinkness",
"pinko",
"pinkroot",
"pinky",
"pinna",
"pinnace",
"pinnacle",
"pinnatiped",
"pinner",
"pinning",
"pinniped",
"pinnipedia",
"pinnotheres",
"pinnotheridae",
"pinnule",
"pinny",
"pinochle",
"pinocle",
"pinocytosis",
"pinole",
"pinon",
"pinophytina",
"pinopsida",
"pinot",
"pinpoint",
"pinprick",
"pinscher",
"pinsk",
"pinstripe",
"pint",
"pintado",
"pintail",
"pinter",
"pintle",
"pinto",
"pinus",
"pinwheel",
"pinworm",
"pinyon",
"piolet",
"pion",
"pioneer",
"piousness",
"pipa",
"pipage",
"pipal",
"pipe",
"pipeclay",
"pipefish",
"pipefitting",
"pipeful",
"pipeline",
"piper",
"piperaceae",
"piperacillin",
"piperales",
"piperazine",
"piperin",
"piperine",
"piperocaine",
"pipet",
"pipette",
"pipework",
"pipewort",
"pipidae",
"pipile",
"pipilo",
"piping",
"pipistrel",
"pipistrelle",
"pipistrellus",
"pipit",
"pippin",
"pipra",
"pipracil",
"pipridae",
"pipsissewa",
"piptadenia",
"pipturus",
"pipul",
"piquance",
"piquancy",
"piquantness",
"pique",
"piqueria",
"piquet",
"piracy",
"pirana",
"pirandello",
"piranga",
"piranha",
"pirate",
"pirogi",
"pirogue",
"piroplasm",
"piroshki",
"pirouette",
"piroxicam",
"pirozhki",
"pisa",
"pisanosaur",
"pisanosaurus",
"piscary",
"pisces",
"piscidia",
"pisiform",
"pismire",
"pisonia",
"piss",
"pisser",
"pissing",
"pissis",
"pistachio",
"pistacia",
"piste",
"pistia",
"pistil",
"pistillode",
"pistol",
"pistoleer",
"piston",
"pisum",
"pita",
"pitahaya",
"pitanga",
"pitch",
"pitchblende",
"pitcher",
"pitcherful",
"pitchfork",
"pitching",
"pitchman",
"pitchstone",
"pitfall",
"pith",
"pithead",
"pithecanthropus",
"pithecellobium",
"pithecia",
"pithecolobium",
"pithiness",
"pitilessness",
"pitman",
"pitocin",
"piton",
"pitot",
"pitprop",
"pitressin",
"pitsaw",
"pitt",
"pitta",
"pittance",
"pittidae",
"pitting",
"pittsburgh",
"pittsfield",
"pituitary",
"pituophis",
"pity",
"pitymys",
"pityriasis",
"pityrogramma",
"piute",
"pivot",
"pixel",
"pixie",
"pixy",
"pizarro",
"pizza",
"pizzaz",
"pizzazz",
"pizzeria",
"pizzicato",
"placard",
"placation",
"place",
"placebo",
"placeholder",
"placekicker",
"placeman",
"placement",
"placenta",
"placental",
"placentation",
"placer",
"placeseeker",
"placidity",
"placidness",
"placidyl",
"placket",
"placoderm",
"placodermi",
"placuna",
"plage",
"plagianthus",
"plagiarisation",
"plagiariser",
"plagiarism",
"plagiarist",
"plagiarization",
"plagiarizer",
"plagiocephaly",
"plagioclase",
"plague",
"plaice",
"plaid",
"plain",
"plainchant",
"plainclothesman",
"plainness",
"plainsman",
"plainsong",
"plaint",
"plaintiff",
"plaintiveness",
"plait",
"plaiter",
"plan",
"planaria",
"planarian",
"planation",
"planchet",
"planchette",
"planck",
"plane",
"planeness",
"planer",
"planera",
"planet",
"planetarium",
"planetesimal",
"planetoid",
"plangency",
"planimeter",
"plank",
"planking",
"plankton",
"planner",
"planning",
"plano",
"planococcus",
"planography",
"plant",
"plantae",
"plantagenet",
"plantaginaceae",
"plantaginales",
"plantago",
"plantain",
"plantation",
"planter",
"planthopper",
"plantigrade",
"planting",
"plantlet",
"plantsman",
"planula",
"plaque",
"plaquenil",
"plash",
"plasm",
"plasma",
"plasmablast",
"plasmacyte",
"plasmacytoma",
"plasmapheresis",
"plasmid",
"plasmin",
"plasminogen",
"plasmodiidae",
"plasmodiophora",
"plasmodium",
"plassey",
"plaster",
"plasterboard",
"plasterer",
"plastering",
"plasterwork",
"plastic",
"plasticine",
"plasticiser",
"plasticity",
"plasticizer",
"plastid",
"plastination",
"plastique",
"plastron",
"plat",
"plataea",
"platalea",
"plataleidae",
"platan",
"platanaceae",
"platanistidae",
"platanthera",
"platanus",
"plate",
"plateau",
"plateful",
"platelayer",
"platelet",
"platen",
"plater",
"platform",
"plath",
"platichthys",
"plating",
"platinum",
"platitude",
"platitudinarian",
"plato",
"platonism",
"platonist",
"platoon",
"plattdeutsch",
"platte",
"plattensee",
"platter",
"platy",
"platycephalidae",
"platycerium",
"platyctenea",
"platyctenean",
"platyhelminth",
"platyhelminthes",
"platylobium",
"platymiscium",
"platypoecilus",
"platypus",
"platyrrhine",
"platyrrhini",
"platyrrhinian",
"platysma",
"platystemon",
"plaudit",
"plaudits",
"plausibility",
"plausibleness",
"plautus",
"plavix",
"play",
"playacting",
"playactor",
"playback",
"playbill",
"playbook",
"playbox",
"playboy",
"playday",
"player",
"playfellow",
"playfulness",
"playgoer",
"playground",
"playhouse",
"playing",
"playlet",
"playlist",
"playmaker",
"playmate",
"playoff",
"playpen",
"playroom",
"playschool",
"playscript",
"playsuit",
"plaything",
"playtime",
"playwright",
"plaza",
"plea",
"pleader",
"pleading",
"pleasance",
"pleasantness",
"pleasantry",
"pleaser",
"pleasing",
"pleasingness",
"pleasure",
"pleat",
"pleating",
"pleb",
"plebe",
"plebeian",
"plebiscite",
"plecoptera",
"plecopteran",
"plecotus",
"plectania",
"plectognath",
"plectognathi",
"plectomycetes",
"plectophera",
"plectorrhiza",
"plectranthus",
"plectron",
"plectrophenax",
"plectrum",
"pledge",
"pledgee",
"pledger",
"pleiades",
"pleione",
"pleiospilos",
"pleistocene",
"plenipotentiary",
"plenitude",
"plenteousness",
"plentifulness",
"plentitude",
"plenty",
"plenum",
"pleochroism",
"pleomorphism",
"pleonasm",
"pleonaste",
"pleopod",
"plesianthropus",
"plesiosaur",
"plesiosauria",
"plesiosaurus",
"plessimeter",
"plessor",
"plethodon",
"plethodont",
"plethodontidae",
"plethora",
"plethysmograph",
"pleura",
"pleuralgia",
"pleurisy",
"pleurobrachia",
"pleurocarp",
"pleurodont",
"pleurodynia",
"pleuronectes",
"pleuronectidae",
"pleuropneumonia",
"pleurosorus",
"pleurothallis",
"pleurotus",
"pleven",
"plevna",
"plexiglas",
"plexiglass",
"pleximeter",
"pleximetry",
"plexor",
"plexus",
"pliability",
"pliancy",
"pliantness",
"plica",
"plication",
"plier",
"pliers",
"plight",
"plimsoll",
"plinth",
"pliny",
"pliocene",
"ploce",
"ploceidae",
"ploceus",
"plod",
"plodder",
"plodding",
"plonk",
"plop",
"plosion",
"plosive",
"plot",
"plotinus",
"plotter",
"plough",
"ploughboy",
"ploughing",
"ploughland",
"ploughman",
"ploughshare",
"ploughwright",
"plovdiv",
"plover",
"plow",
"plowboy",
"plower",
"plowing",
"plowland",
"plowman",
"plowshare",
"plowwright",
"ploy",
"pluck",
"pluckiness",
"plug",
"plugboard",
"plugger",
"plughole",
"plum",
"plumage",
"plumb",
"plumbaginaceae",
"plumbaginales",
"plumbago",
"plumber",
"plumbery",
"plumbing",
"plumbism",
"plumcot",
"plume",
"plumeria",
"plumiera",
"plummet",
"plump",
"plumpness",
"plumule",
"plunder",
"plunderage",
"plunderer",
"plundering",
"plunge",
"plunger",
"plunk",
"plunker",
"pluperfect",
"plural",
"pluralisation",
"pluralism",
"pluralist",
"plurality",
"pluralization",
"plus",
"plush",
"plutarch",
"pluteaceae",
"pluteus",
"pluto",
"plutocracy",
"plutocrat",
"pluton",
"plutonium",
"pluvialis",
"pluvianus",
"pluviometer",
"pluviose",
"plyboard",
"plyer",
"plyers",
"plymouth",
"plywood",
"plzen",
"pneumatics",
"pneumatophore",
"pneumococcus",
"pneumoconiosis",
"pneumocytosis",
"pneumogastric",
"pneumonectomy",
"pneumonia",
"pneumonitis",
"pneumothorax",
"pneumovax",
"poaceae",
"poacher",
"poaching",
"pocahontas",
"pocatello",
"pochard",
"pock",
"pocket",
"pocketbook",
"pocketcomb",
"pocketful",
"pocketknife",
"pockmark",
"podalgia",
"podalyria",
"podargidae",
"podargus",
"podaxaceae",
"podetium",
"podiatrist",
"podiatry",
"podiceps",
"podicipedidae",
"podilymbus",
"podium",
"podocarp",
"podocarpaceae",
"podocarpus",
"podophyllum",
"podsol",
"podzol",
"poeciliid",
"poeciliidae",
"poecilocapsus",
"poecilogale",
"poem",
"poenology",
"poephila",
"poesy",
"poet",
"poetess",
"poetics",
"poetiser",
"poetizer",
"poetry",
"pogey",
"pogge",
"pogonia",
"pogonion",
"pogonip",
"pogonophora",
"pogonophoran",
"pogostemon",
"pogrom",
"pogy",
"poignance",
"poignancy",
"poikilotherm",
"poilu",
"poinciana",
"poinsettia",
"point",
"pointedness",
"pointel",
"pointer",
"pointillism",
"pointillist",
"pointlessness",
"pointrel",
"pointsman",
"poise",
"poison",
"poisonberry",
"poisoner",
"poisoning",
"poitier",
"poitiers",
"poitou",
"poivrade",
"poke",
"poker",
"pokeweed",
"pokey",
"poking",
"pokomo",
"poky",
"polack",
"poland",
"polanisia",
"polarimeter",
"polaris",
"polarisation",
"polariscope",
"polarity",
"polarization",
"polarography",
"polaroid",
"polder",
"pole",
"poleax",
"poleaxe",
"polecat",
"polemic",
"polemicist",
"polemics",
"polemist",
"polemoniaceae",
"polemoniales",
"polemonium",
"polenta",
"poler",
"polestar",
"polianthes",
"police",
"policeman",
"policewoman",
"policy",
"policyholder",
"polio",
"poliomyelitis",
"polioptila",
"poliosis",
"poliovirus",
"polish",
"polisher",
"polishing",
"polistes",
"politburo",
"politeness",
"politesse",
"politician",
"politico",
"politics",
"polity",
"polk",
"polka",
"poll",
"pollachius",
"pollack",
"pollard",
"pollen",
"pollenation",
"pollex",
"pollination",
"pollinator",
"pollinium",
"pollinosis",
"polliwog",
"pollock",
"polls",
"pollster",
"pollucite",
"pollutant",
"polluter",
"pollution",
"pollux",
"pollyfish",
"pollywog",
"polo",
"polonaise",
"polonium",
"polony",
"polska",
"poltergeist",
"poltroon",
"poltroonery",
"polyamide",
"polyandrist",
"polyandry",
"polyangiaceae",
"polyangium",
"polyanthus",
"polyarteritis",
"polyborus",
"polybotria",
"polybotrya",
"polybutene",
"polybutylene",
"polycarp",
"polychaeta",
"polychaete",
"polychete",
"polychrome",
"polycillin",
"polycirrus",
"polycythemia",
"polydactylus",
"polydactyly",
"polydipsia",
"polyelectrolyte",
"polyergus",
"polyester",
"polyethylene",
"polyfoam",
"polygala",
"polygalaceae",
"polygamist",
"polygamy",
"polygene",
"polyglot",
"polygon",
"polygonaceae",
"polygonales",
"polygonatum",
"polygonia",
"polygonum",
"polygraph",
"polygynist",
"polygyny",
"polyhedron",
"polyhidrosis",
"polyhymnia",
"polymastigina",
"polymastigote",
"polymath",
"polymer",
"polymerase",
"polymerisation",
"polymerization",
"polymorph",
"polymorphism",
"polymox",
"polymyositis",
"polymyxin",
"polynemidae",
"polynesia",
"polynesian",
"polyneuritis",
"polynomial",
"polynucleotide",
"polynya",
"polyodon",
"polyodontidae",
"polyoma",
"polyose",
"polyp",
"polypectomy",
"polypedates",
"polypedatidae",
"polypeptide",
"polyphone",
"polyphony",
"polyphosphate",
"polyplacophora",
"polyplacophore",
"polyploid",
"polyploidy",
"polypodiaceae",
"polypodiales",
"polypodium",
"polypody",
"polyporaceae",
"polypore",
"polyporus",
"polyprion",
"polypropene",
"polypropylene",
"polyptoton",
"polypus",
"polysaccharide",
"polysemant",
"polysemy",
"polysomy",
"polystichum",
"polystyrene",
"polysyllable",
"polysyndeton",
"polytechnic",
"polytheism",
"polytheist",
"polythene",
"polytonalism",
"polytonality",
"polyurethan",
"polyurethane",
"polyuria",
"polyvalence",
"polyvalency",
"polyzoa",
"polyzoan",
"pomacanthus",
"pomacentridae",
"pomacentrus",
"pomade",
"pomaderris",
"pomatomidae",
"pomatomus",
"pomatum",
"pome",
"pomegranate",
"pomelo",
"pomeranian",
"pomfret",
"pommel",
"pommy",
"pomo",
"pomolobus",
"pomologist",
"pomology",
"pomoxis",
"pomp",
"pompadour",
"pompano",
"pompeii",
"pompey",
"pompon",
"pomposity",
"pompousness",
"ponca",
"ponce",
"poncho",
"poncirus",
"pond",
"ponderer",
"ponderosa",
"ponderosity",
"ponderousness",
"pondweed",
"pone",
"pong",
"pongamia",
"pongee",
"pongid",
"pongidae",
"pongo",
"poniard",
"ponka",
"pons",
"ponselle",
"ponstel",
"pontederia",
"pontederiaceae",
"pontiac",
"pontifex",
"pontiff",
"pontifical",
"pontificate",
"pontoon",
"pontos",
"pontus",
"pony",
"ponycart",
"ponytail",
"pooch",
"pood",
"poodle",
"pooecetes",
"poof",
"pool",
"pooler",
"poolroom",
"poon",
"poop",
"poor",
"poorhouse",
"poorness",
"poorwill",
"poove",
"popcorn",
"pope",
"popery",
"popgun",
"popillia",
"popinjay",
"poplar",
"poplin",
"popover",
"popper",
"poppet",
"popping",
"poppy",
"poppycock",
"popsicle",
"populace",
"popularisation",
"populariser",
"popularism",
"popularity",
"popularization",
"popularizer",
"population",
"populism",
"populist",
"populus",
"porbeagle",
"porc",
"porcelain",
"porcellio",
"porcellionidae",
"porch",
"porcupine",
"porcupinefish",
"porcupines",
"pore",
"porgy",
"porifera",
"poriferan",
"pork",
"porkchop",
"porker",
"porkfish",
"porkholt",
"porkpie",
"porn",
"porno",
"pornographer",
"pornography",
"poronotus",
"poroporo",
"porosity",
"porousness",
"porphyra",
"porphyria",
"porphyrin",
"porphyrio",
"porphyrula",
"porphyry",
"porpoise",
"porridge",
"porringer",
"port",
"porta",
"portability",
"portable",
"portage",
"portal",
"portcullis",
"porte",
"portent",
"porter",
"porterage",
"porterhouse",
"portfolio",
"porthole",
"portico",
"portiere",
"portion",
"portland",
"portmanteau",
"porto",
"portrait",
"portraitist",
"portraiture",
"portrayal",
"portrayer",
"portraying",
"portsmouth",
"portugal",
"portuguese",
"portulaca",
"portulacaceae",
"portunidae",
"portunus",
"portwatcher",
"porzana",
"pose",
"poseidon",
"poser",
"poseur",
"poseuse",
"posing",
"posit",
"position",
"positioner",
"positioning",
"positive",
"positiveness",
"positivism",
"positivist",
"positivity",
"positron",
"posology",
"posse",
"posseman",
"possession",
"possessive",
"possessiveness",
"possessor",
"posset",
"possibility",
"possible",
"possibleness",
"possum",
"possumwood",
"post",
"postage",
"postbag",
"postbox",
"postcard",
"postcava",
"postcode",
"postdiluvian",
"postdoc",
"postdoctoral",
"poster",
"posterboard",
"posterior",
"posteriority",
"posterity",
"postern",
"postfix",
"postgraduate",
"posthitis",
"posthole",
"posthouse",
"postiche",
"postilion",
"postillion",
"posting",
"postlude",
"postman",
"postmark",
"postmaster",
"postmistress",
"postmodernism",
"postmortem",
"postponement",
"postponer",
"postposition",
"postscript",
"postulant",
"postulate",
"postulation",
"postulator",
"postum",
"posture",
"posturer",
"posturing",
"posy",
"potable",
"potage",
"potamogale",
"potamogalidae",
"potamogeton",
"potamophis",
"potash",
"potassium",
"potation",
"potato",
"potawatomi",
"potbelly",
"potboiler",
"potboy",
"poteen",
"potemkin",
"potence",
"potency",
"potentate",
"potential",
"potentiality",
"potentiation",
"potentilla",
"potentiometer",
"poterium",
"potful",
"pothead",
"pother",
"potherb",
"potholder",
"pothole",
"potholer",
"pothook",
"pothos",
"pothouse",
"pothunter",
"potion",
"potlatch",
"potluck",
"potman",
"potomac",
"potomania",
"potoroinae",
"potoroo",
"potorous",
"potos",
"potpie",
"potpourri",
"potsdam",
"potsherd",
"potshot",
"pottage",
"potter",
"potterer",
"pottery",
"pottle",
"potto",
"potty",
"potyokin",
"pouch",
"poudrin",
"pouf",
"pouffe",
"poulenc",
"poulet",
"poulette",
"poulterer",
"poultice",
"poultry",
"poultryman",
"pounce",
"pound",
"poundage",
"poundal",
"pounder",
"pounding",
"pourboire",
"poussin",
"pout",
"pouter",
"pouteria",
"poverty",
"powder",
"powderer",
"powderiness",
"powderpuff",
"powell",
"power",
"powerboat",
"powerbroker",
"powerfulness",
"powerhouse",
"powerlessness",
"powhatan",
"powwow",
"powys",
"poxvirus",
"poyang",
"poyou",
"pozsony",
"pplo",
"practicability",
"practicableness",
"practicality",
"practice",
"practician",
"practitioner",
"praenomen",
"praesidium",
"praetor",
"praetorian",
"praetorium",
"praetorship",
"prag",
"pragmatic",
"pragmatics",
"pragmatism",
"pragmatist",
"prague",
"praha",
"praia",
"prairial",
"prairie",
"praise",
"praisworthiness",
"prajapati",
"prakrit",
"praline",
"pram",
"prance",
"prancer",
"prang",
"prank",
"prankishness",
"prankster",
"praseodymium",
"prat",
"prate",
"prater",
"pratfall",
"pratincole",
"prattle",
"prattler",
"praunus",
"pravachol",
"pravastatin",
"prawn",
"praxis",
"praxiteles",
"praya",
"prayer",
"prayerbook",
"prazosin",
"preacher",
"preachification",
"preaching",
"preachment",
"preakness",
"preamble",
"prearrangement",
"prebend",
"prebendary",
"precambrian",
"precariousness",
"precaution",
"precava",
"precedence",
"precedency",
"precedent",
"precentor",
"precentorship",
"precept",
"preceptor",
"preceptorship",
"precession",
"prechlorination",
"precinct",
"preciosity",
"preciousness",
"precipice",
"precipitance",
"precipitancy",
"precipitant",
"precipitate",
"precipitateness",
"precipitation",
"precipitator",
"precipitin",
"precipitousness",
"precis",
"preciseness",
"precision",
"preclusion",
"precociousness",
"precocity",
"precognition",
"preconception",
"precondition",
"precordium",
"precursor",
"predation",
"predator",
"predecessor",
"predestinarian",
"predestination",
"predicament",
"predicate",
"predication",
"predicator",
"predictability",
"prediction",
"predictor",
"predilection",
"predisposition",
"prednisolone",
"prednisone",
"predominance",
"predomination",
"preeclampsia",
"preemie",
"preeminence",
"preempt",
"preemption",
"preemptor",
"preexistence",
"prefab",
"prefabrication",
"preface",
"prefect",
"prefecture",
"preference",
"preferment",
"prefiguration",
"prefix",
"prefixation",
"preformation",
"pregnancy",
"pregnanediol",
"prehension",
"prehensor",
"prehistory",
"preindication",
"prejudgement",
"prejudgment",
"prejudice",
"prelacy",
"prelate",
"prelature",
"prelim",
"preliminary",
"prelims",
"prelone",
"prelude",
"prematureness",
"prematurity",
"premeditation",
"premie",
"premier",
"premiere",
"premiership",
"premise",
"premises",
"premiss",
"premium",
"premix",
"premolar",
"premonition",
"prenanthes",
"prentice",
"preoccupancy",
"preoccupation",
"preordination",
"prep",
"preparation",
"preparedness",
"prepayment",
"preponderance",
"preposition",
"prepossession",
"prepotency",
"prepuberty",
"prepuce",
"prerequisite",
"prerogative",
"presage",
"presbyope",
"presbyopia",
"presbyter",
"presbyterian",
"presbyterianism",
"presbytery",
"presbytes",
"preschool",
"preschooler",
"prescience",
"prescott",
"prescript",
"prescription",
"prescriptivism",
"preseason",
"presence",
"present",
"presentation",
"presenter",
"presentiment",
"presentism",
"presentist",
"presentment",
"presentness",
"preservation",
"preservationist",
"preservative",
"preserve",
"preserver",
"preserves",
"presidency",
"president",
"presidentship",
"presidio",
"presidium",
"presley",
"press",
"pressburg",
"pressing",
"pressman",
"pressmark",
"pressor",
"pressure",
"prestidigitator",
"prestige",
"prestigiousness",
"presumption",
"presupposition",
"preteen",
"preteenager",
"pretence",
"pretend",
"pretender",
"pretending",
"pretense",
"pretension",
"pretentiousness",
"preterist",
"preterit",
"preterite",
"preterition",
"pretermission",
"pretext",
"pretor",
"pretoria",
"pretorium",
"pretrial",
"prettiness",
"pretzel",
"preussen",
"prevacid",
"prevalence",
"prevarication",
"prevaricator",
"preventative",
"prevention",
"preventive",
"preview",
"prevision",
"prevue",
"prexy",
"prey",
"priacanthidae",
"priacanthus",
"priam",
"priapism",
"priapus",
"price",
"pricelessness",
"pricing",
"prick",
"pricker",
"pricket",
"pricking",
"prickle",
"prickleback",
"prickliness",
"prickling",
"prickteaser",
"pride",
"pridefulness",
"priest",
"priestcraft",
"priestess",
"priesthood",
"priestley",
"prig",
"priggishness",
"prilosec",
"prima",
"primacy",
"primality",
"primaquine",
"primary",
"primate",
"primates",
"primateship",
"primatology",
"primaxin",
"prime",
"primer",
"primidone",
"primigravida",
"priming",
"primipara",
"primitive",
"primitiveness",
"primitivism",
"primness",
"primo",
"primogenitor",
"primogeniture",
"primordium",
"primping",
"primrose",
"primula",
"primulaceae",
"primulales",
"primus",
"prince",
"princedom",
"princeling",
"princess",
"princeton",
"princewood",
"principal",
"principality",
"principalship",
"principe",
"principen",
"principle",
"prinia",
"prinival",
"print",
"printer",
"printing",
"printmaker",
"printmaking",
"printout",
"priodontes",
"prion",
"prionace",
"prionotus",
"prior",
"prioress",
"priority",
"priorship",
"priory",
"priscoan",
"prism",
"prismatoid",
"prismoid",
"prison",
"prisonbreak",
"prisoner",
"pristidae",
"pristis",
"pritzelago",
"privacy",
"private",
"privateer",
"privateersman",
"privateness",
"privates",
"privation",
"privatisation",
"privatization",
"privet",
"privilege",
"privine",
"privy",
"prize",
"prizefight",
"prizefighter",
"proaccelerin",
"probabilism",
"probability",
"probable",
"probate",
"probation",
"probationer",
"probe",
"probenecid",
"probiotic",
"probity",
"problem",
"proboscidea",
"proboscidean",
"proboscidian",
"proboscis",
"procaine",
"procarbazine",
"procardia",
"procaryote",
"procavia",
"procaviidae",
"procedure",
"proceeding",
"proceedings",
"proceeds",
"procellaria",
"procellariidae",
"process",
"processing",
"procession",
"processional",
"processor",
"prociphilus",
"proclamation",
"proclivity",
"procnias",
"proconsul",
"proconsulate",
"proconsulship",
"proconvertin",
"procrastination",
"procrastinator",
"procreation",
"procrustes",
"proctalgia",
"proctitis",
"proctocele",
"proctologist",
"proctology",
"proctoplasty",
"proctor",
"proctorship",
"proctoscope",
"proctoscopy",
"procural",
"procurance",
"procurator",
"procurement",
"procurer",
"procuress",
"procyclidine",
"procyon",
"procyonid",
"procyonidae",
"prod",
"prodding",
"prodigal",
"prodigality",
"prodigy",
"prodroma",
"prodrome",
"produce",
"producer",
"product",
"production",
"productiveness",
"productivity",
"proenzyme",
"prof",
"profanation",
"profaneness",
"profanity",
"professing",
"profession",
"professional",
"professionalism",
"professor",
"professorship",
"proffer",
"proficiency",
"profile",
"profiling",
"profit",
"profitability",
"profitableness",
"profiteer",
"profiterole",
"profits",
"profligacy",
"profligate",
"profoundness",
"profundity",
"profuseness",
"profusion",
"progenitor",
"progeny",
"progeria",
"progesterone",
"progestin",
"progestogen",
"prognathism",
"progne",
"prognosis",
"prognostic",
"prognostication",
"prognosticator",
"program",
"programing",
"programma",
"programme",
"programmer",
"programming",
"progress",
"progression",
"progressive",
"progressiveness",
"progressivism",
"progressivity",
"progymnosperm",
"prohibition",
"prohibitionist",
"project",
"projectile",
"projection",
"projectionist",
"projector",
"prokaryote",
"prokayotae",
"prokhorov",
"prokofiev",
"prolactin",
"prolamine",
"prolapse",
"prolapsus",
"prole",
"prolegomenon",
"prolepsis",
"proletarian",
"proletariat",
"proliferation",
"prolificacy",
"proline",
"prolixity",
"prolixness",
"prolog",
"prologue",
"prolongation",
"prolonge",
"prolusion",
"prom",
"promenade",
"promethazine",
"prometheus",
"promethium",
"prominence",
"promiscuity",
"promiscuousness",
"promise",
"promisee",
"promiser",
"promisor",
"promo",
"promontory",
"promoter",
"promotion",
"prompt",
"promptbook",
"prompter",
"prompting",
"promptitude",
"promptness",
"promulgation",
"promulgator",
"promycelium",
"pronation",
"pronator",
"proneness",
"prong",
"prongbuck",
"pronghorn",
"pronominal",
"pronoun",
"pronouncement",
"pronucleus",
"pronunciamento",
"pronunciation",
"proof",
"proofreader",
"prop",
"propaedeutic",
"propaedeutics",
"propaganda",
"propagandist",
"propagation",
"propagator",
"propanal",
"propanamide",
"propane",
"propanediol",
"propanol",
"propanolol",
"propanone",
"proparoxytone",
"propellant",
"propellent",
"propeller",
"propellor",
"propenal",
"propene",
"propenoate",
"propenonitrile",
"propensity",
"properness",
"property",
"prophase",
"prophecy",
"prophesier",
"prophet",
"prophetess",
"prophets",
"prophylactic",
"prophylaxis",
"prophyll",
"propinquity",
"propionaldehyde",
"propitiation",
"propitiousness",
"propjet",
"propman",
"proponent",
"proportion",
"proportional",
"proportionality",
"proposal",
"proposer",
"proposition",
"propositus",
"propoxyphene",
"proprietary",
"proprietor",
"proprietorship",
"proprietress",
"propriety",
"proprioception",
"proprioceptor",
"proprionamide",
"props",
"propulsion",
"propyl",
"propylene",
"proration",
"prorogation",
"prosaicness",
"prosauropoda",
"proscenium",
"prosciutto",
"proscription",
"prose",
"prosecution",
"prosecutor",
"proselyte",
"proselytism",
"prosencephalon",
"proserpina",
"proserpine",
"prosimian",
"prosimii",
"prosiness",
"prosodion",
"prosody",
"prosom",
"prosopis",
"prosopium",
"prosopopoeia",
"prospect",
"prospector",
"prospectus",
"prosperity",
"prospicience",
"prostaglandin",
"prostate",
"prostatectomy",
"prostatitis",
"prostheon",
"prosthesis",
"prosthetics",
"prosthetist",
"prosthion",
"prosthodontia",
"prosthodontics",
"prosthodontist",
"prostigmin",
"prostitute",
"prostitution",
"prostration",
"protactinium",
"protagonism",
"protagonist",
"protamine",
"protanopia",
"protea",
"proteaceae",
"proteales",
"protease",
"protection",
"protectionism",
"protectionist",
"protectiveness",
"protector",
"protectorate",
"protectorship",
"protege",
"protegee",
"proteidae",
"protein",
"proteinase",
"proteinuria",
"proteles",
"proteolysis",
"proteome",
"proteomics",
"proteosome",
"proterochampsa",
"proterozoic",
"protest",
"protestant",
"protestantism",
"protestation",
"protester",
"proteus",
"prothalamion",
"prothalamium",
"prothorax",
"prothrombin",
"prothrombinase",
"protirelin",
"protist",
"protista",
"protistan",
"protium",
"protoactinium",
"protoarcheology",
"protoavis",
"protoceratops",
"protocol",
"protoctist",
"protoctista",
"protoheme",
"protohemin",
"protohippus",
"protohistory",
"protology",
"protomammal",
"proton",
"protoplasm",
"protoplast",
"prototheria",
"prototherian",
"prototype",
"protozoa",
"protozoan",
"protozoologist",
"protozoology",
"protozoon",
"protraction",
"protractor",
"protriptyline",
"protropin",
"protrusion",
"protuberance",
"protura",
"proturan",
"proudhon",
"proust",
"provability",
"provenance",
"provencal",
"provence",
"provender",
"provenience",
"proventil",
"provera",
"proverb",
"proverbs",
"providence",
"provider",
"province",
"provincial",
"provincialism",
"provirus",
"provision",
"provisioner",
"provisions",
"proviso",
"provitamin",
"provo",
"provocateur",
"provocation",
"provoker",
"provos",
"provost",
"prow",
"prowess",
"prowl",
"prowler",
"proxemics",
"proxima",
"proximity",
"proxy",
"prozac",
"prude",
"prudence",
"prudery",
"prudishness",
"prumnopitys",
"prune",
"prunella",
"prunellidae",
"pruner",
"pruning",
"pruno",
"prunus",
"prurience",
"pruriency",
"prurigo",
"pruritus",
"prussia",
"prussian",
"prying",
"psalm",
"psalmist",
"psalmody",
"psalms",
"psalter",
"psalterium",
"psaltery",
"psaltriparus",
"psammoma",
"psenes",
"psephologist",
"psephology",
"psephurus",
"psetta",
"psettichthys",
"pseud",
"pseudacris",
"pseudaletia",
"pseudechis",
"pseudemys",
"pseudepigrapha",
"pseudo",
"pseudobombax",
"pseudobulb",
"pseudocarp",
"pseudococcidae",
"pseudococcus",
"pseudocolus",
"pseudocyesis",
"pseudoephedrine",
"pseudolarix",
"pseudomonad",
"pseudomonadales",
"pseudomonas",
"pseudonym",
"pseudophloem",
"pseudopod",
"pseudopodium",
"pseudorubella",
"pseudoryx",
"pseudoscience",
"pseudoscorpion",
"pseudosmallpox",
"pseudotaxus",
"pseudotsuga",
"pseudovariola",
"pseudowintera",
"psidium",
"psilocin",
"psilocybin",
"psilomelane",
"psilophytaceae",
"psilophytales",
"psilophyte",
"psilophyton",
"psilopsida",
"psilosis",
"psilotaceae",
"psilotales",
"psilotatae",
"psilotum",
"psithyrus",
"psittacidae",
"psittaciformes",
"psittacosaur",
"psittacosaurus",
"psittacosis",
"psittacula",
"psittacus",
"psoas",
"psocid",
"psocidae",
"psocoptera",
"psophia",
"psophiidae",
"psophocarpus",
"psoralea",
"psoriasis",
"psyche",
"psychedelia",
"psychiatrist",
"psychiatry",
"psychic",
"psycho",
"psychoanalysis",
"psychoanalyst",
"psychobabble",
"psychodid",
"psychodidae",
"psychodynamics",
"psychogenesis",
"psychokinesis",
"psycholinguist",
"psychologist",
"psychology",
"psychometrics",
"psychometrika",
"psychometry",
"psychoneurosis",
"psychoneurotic",
"psychonomics",
"psychopath",
"psychopathology",
"psychopathy",
"psychophysicist",
"psychophysics",
"psychopomp",
"psychopsis",
"psychosexuality",
"psychosis",
"psychosurgery",
"psychotherapist",
"psychotherapy",
"psychotic",
"psychotria",
"psychrometer",
"psylla",
"psyllid",
"psyllidae",
"psyllium",
"psyop",
"ptah",
"ptarmigan",
"pteretis",
"pteridaceae",
"pteridium",
"pteridologist",
"pteridology",
"pteridophyta",
"pteridophyte",
"pteridosperm",
"pteridospermae",
"pteriidae",
"pterion",
"pteris",
"pternohyla",
"pterocarpus",
"pterocarya",
"pterocles",
"pteroclididae",
"pterocnemia",
"pterodactyl",
"pterodactylidae",
"pterodactylus",
"pterois",
"pteropogon",
"pteropsida",
"pteropus",
"pterosaur",
"pterosauria",
"pterospermum",
"pterostylis",
"pterygium",
"ptilocercus",
"ptilocrinus",
"ptilonorhynchus",
"ptloris",
"ptolemy",
"ptomain",
"ptomaine",
"ptosis",
"ptsd",
"ptyalin",
"ptyalism",
"ptyalith",
"ptyas",
"ptychozoon",
"puberty",
"pubes",
"pubescence",
"pubis",
"public",
"publican",
"publication",
"publiciser",
"publicist",
"publicity",
"publicizer",
"publicizing",
"publisher",
"publishing",
"puccini",
"puccinia",
"pucciniaceae",
"puccoon",
"puce",
"puck",
"pucker",
"puckerbush",
"puckishness",
"pudding",
"puddingwife",
"puddle",
"puddler",
"pudendum",
"pudge",
"pudginess",
"puebla",
"pueblo",
"pueraria",
"puerility",
"puerpera",
"puerperium",
"puff",
"puffball",
"puffbird",
"puffer",
"pufferfish",
"puffery",
"puffin",
"puffiness",
"puffing",
"puffinus",
"pugilism",
"pugilist",
"pugin",
"puglia",
"pugnacity",
"puissance",
"pujunan",
"puka",
"puke",
"puking",
"puku",
"pula",
"pulasan",
"pulassan",
"pulchritude",
"pulex",
"pulicaria",
"pulicidae",
"pulitzer",
"pull",
"pullback",
"puller",
"pullet",
"pulley",
"pulling",
"pullman",
"pullout",
"pullover",
"pullulation",
"pulmonata",
"pulp",
"pulpiness",
"pulpit",
"pulpwood",
"pulque",
"pulsar",
"pulsatilla",
"pulsation",
"pulse",
"pulsing",
"pulverisation",
"pulverization",
"puma",
"pumice",
"pummelo",
"pump",
"pumpernickel",
"pumpkin",
"pumpkinseed",
"punch",
"punchayet",
"punchball",
"punchboard",
"puncher",
"punctilio",
"punctiliousness",
"punctuality",
"punctuation",
"punctum",
"puncture",
"pundit",
"pung",
"pungapung",
"pungency",
"punic",
"punica",
"punicaceae",
"puniness",
"punishment",
"punjab",
"punjabi",
"punk",
"punkah",
"punkey",
"punkie",
"punks",
"punky",
"punnet",
"punning",
"punster",
"punt",
"punter",
"punting",
"pupa",
"pupil",
"puppet",
"puppeteer",
"puppetry",
"puppis",
"puppy",
"purace",
"purana",
"purau",
"purcell",
"purchase",
"purchaser",
"purchasing",
"purdah",
"pureblood",
"purebred",
"puree",
"pureness",
"purgation",
"purgative",
"purgatory",
"purge",
"purging",
"purification",
"purifier",
"purim",
"purine",
"purinethol",
"purism",
"purist",
"puritan",
"puritanism",
"purity",
"purkinje",
"purl",
"purlieu",
"purloo",
"purple",
"purpleness",
"purport",
"purpose",
"purposefulness",
"purposelessness",
"purpura",
"purr",
"purse",
"purser",
"purslane",
"pursual",
"pursuance",
"pursued",
"pursuer",
"pursuit",
"purulence",
"purulency",
"purus",
"purveyance",
"purveyor",
"purview",
"pusan",
"pusey",
"puseyism",
"push",
"pushan",
"pushball",
"pushcart",
"pushchair",
"pusher",
"pushiness",
"pushing",
"pushkin",
"pushover",
"pushpin",
"pushtun",
"pushup",
"pusillanimity",
"puss",
"pussley",
"pussly",
"pussy",
"pussycat",
"pussytoes",
"pustule",
"putamen",
"putin",
"putoff",
"putout",
"putrajaya",
"putrefaction",
"putrescence",
"putrescine",
"putridity",
"putridness",
"putsch",
"putt",
"puttee",
"putter",
"putterer",
"putting",
"putty",
"puttyroot",
"putz",
"puzzle",
"puzzlement",
"puzzler",
"pyaemia",
"pycnanthemum",
"pycnidium",
"pycnodysostosis",
"pycnogonid",
"pycnogonida",
"pycnosis",
"pydna",
"pyelitis",
"pyelogram",
"pyelography",
"pyelonephritis",
"pyemia",
"pygmalion",
"pygmy",
"pygopodidae",
"pygopus",
"pygoscelis",
"pyinma",
"pyjama",
"pyknosis",
"pyle",
"pylodictus",
"pylon",
"pylorus",
"pynchon",
"pyocyanase",
"pyocyanin",
"pyongyang",
"pyorrhea",
"pyorrhoea",
"pyracanth",
"pyracantha",
"pyralid",
"pyralidae",
"pyralididae",
"pyralis",
"pyramid",
"pyramiding",
"pyrausta",
"pyre",
"pyrectic",
"pyrene",
"pyrenees",
"pyrenomycetes",
"pyrethrum",
"pyrex",
"pyrexia",
"pyridine",
"pyridium",
"pyridoxal",
"pyridoxamine",
"pyridoxine",
"pyrilamine",
"pyrimidine",
"pyrite",
"pyrites",
"pyrocellulose",
"pyrocephalus",
"pyrochemistry",
"pyroelectricity",
"pyrogallol",
"pyrogen",
"pyrograph",
"pyrographer",
"pyrography",
"pyrola",
"pyrolaceae",
"pyrolatry",
"pyrolusite",
"pyrolysis",
"pyromancer",
"pyromancy",
"pyromania",
"pyromaniac",
"pyrometer",
"pyromorphite",
"pyrope",
"pyrophobia",
"pyrophorus",
"pyrophosphate",
"pyrophyllite",
"pyroscope",
"pyrosis",
"pyrostat",
"pyrotechnic",
"pyrotechnics",
"pyrotechny",
"pyroxene",
"pyroxylin",
"pyroxyline",
"pyrrhic",
"pyrrhocoridae",
"pyrrhotine",
"pyrrhotite",
"pyrrhula",
"pyrrhuloxia",
"pyrrhus",
"pyrrophyta",
"pyrrosia",
"pyrularia",
"pyrus",
"pythagoras",
"pythia",
"pythiaceae",
"pythias",
"pythium",
"pythius",
"python",
"pythoness",
"pythonidae",
"pythoninae",
"pyuria",
"pyxidanthera",
"pyxidium",
"pyxie",
"pyxis",
"qabala",
"qabalah",
"qabbala",
"qabbalah",
"qaddafi",
"qadhafi",
"qadi",
"qaeda",
"qandahar",
"qatar",
"qatari",
"qepiq",
"qiang",
"qiangic",
"qibla",
"qindarka",
"qing",
"qintar",
"qoph",
"quaalude",
"quack",
"quackery",
"quackgrass",
"quad",
"quadragesima",
"quadrangle",
"quadrant",
"quadrantanopia",
"quadraphony",
"quadrate",
"quadratic",
"quadratics",
"quadrature",
"quadrennium",
"quadric",
"quadriceps",
"quadrilateral",
"quadrille",
"quadrillion",
"quadrillionth",
"quadripara",
"quadriplegia",
"quadriplegic",
"quadrivium",
"quadroon",
"quadrumvirate",
"quadruped",
"quadruple",
"quadruplet",
"quadruplicate",
"quadrupling",
"quaestor",
"quaff",
"quaffer",
"quag",
"quagga",
"quagmire",
"quahaug",
"quahog",
"quail",
"quaintness",
"quake",
"quaker",
"quakerism",
"quakers",
"qualification",
"qualifier",
"qualifying",
"quality",
"qualm",
"quamash",
"quamassia",
"quandang",
"quandary",
"quandong",
"quango",
"quantic",
"quantifiability",
"quantification",
"quantifier",
"quantisation",
"quantity",
"quantization",
"quantong",
"quantum",
"quaoar",
"quapaw",
"quarantine",
"quark",
"quarrel",
"quarreler",
"quarreller",
"quarrelsomeness",
"quarrier",
"quarry",
"quarrying",
"quarryman",
"quart",
"quartan",
"quarter",
"quarterback",
"quarterdeck",
"quarterfinal",
"quartering",
"quarterlight",
"quarterly",
"quartermaster",
"quartern",
"quarters",
"quarterstaff",
"quartervine",
"quartet",
"quartette",
"quartic",
"quartile",
"quarto",
"quartz",
"quartzite",
"quasar",
"quasiparticle",
"quassia",
"quat",
"quatercentenary",
"quatern",
"quaternary",
"quaternion",
"quaternity",
"quatrain",
"quattrocento",
"quaver",
"quay",
"quayage",
"queasiness",
"quebec",
"quebecois",
"quechua",
"quechuan",
"queen",
"queenfish",
"queens",
"queensland",
"queer",
"queerness",
"quelling",
"quellung",
"quenching",
"quercitron",
"quercus",
"querier",
"quern",
"querulousness",
"query",
"quesadilla",
"quest",
"quester",
"question",
"questioner",
"questioning",
"questionnaire",
"quetzal",
"quetzalcoatl",
"queue",
"quiaquia",
"quibble",
"quibbler",
"quiche",
"quick",
"quickener",
"quickening",
"quickie",
"quicklime",
"quickness",
"quicksand",
"quickset",
"quicksilver",
"quickstep",
"quicky",
"quid",
"quiddity",
"quidnunc",
"quiescence",
"quiescency",
"quiet",
"quietism",
"quietist",
"quietness",
"quietude",
"quietus",
"quiff",
"quill",
"quillwort",
"quilt",
"quilting",
"quin",
"quinacrine",
"quince",
"quincentenary",
"quincentennial",
"quincy",
"quine",
"quinidex",
"quinidine",
"quinine",
"quinone",
"quinora",
"quinquagesima",
"quinquennium",
"quinsy",
"quint",
"quintal",
"quintessence",
"quintet",
"quintette",
"quintillion",
"quintillionth",
"quintipara",
"quintuple",
"quintuplet",
"quintupling",
"quip",
"quipu",
"quira",
"quire",
"quirk",
"quirkiness",
"quirt",
"quiscalus",
"quisling",
"quislingism",
"quitclaim",
"quito",
"quittance",
"quitter",
"quiver",
"quivering",
"quixotism",
"quiz",
"quizmaster",
"quizzer",
"quodlibet",
"quoin",
"quoit",
"quoits",
"quoratean",
"quorum",
"quota",
"quotability",
"quotation",
"quote",
"quoter",
"quotient",
"quran",
"qurush",
"rabat",
"rabato",
"rabbet",
"rabbi",
"rabbinate",
"rabbit",
"rabbiteye",
"rabbitfish",
"rabbitweed",
"rabbitwood",
"rabble",
"rabelais",
"rabidity",
"rabidness",
"rabies",
"raccoon",
"race",
"raceabout",
"racecard",
"racecourse",
"racehorse",
"raceme",
"racer",
"racerunner",
"racetrack",
"raceway",
"rachel",
"rachet",
"rachis",
"rachischisis",
"rachitis",
"rachmaninoff",
"rachmaninov",
"rachycentridae",
"rachycentron",
"racialism",
"racialist",
"racine",
"raciness",
"racing",
"racism",
"racist",
"rack",
"racker",
"racket",
"racketeer",
"racketeering",
"racketiness",
"racon",
"raconteur",
"racoon",
"racquet",
"racquetball",
"radar",
"raddle",
"radhakrishnan",
"radial",
"radian",
"radiance",
"radiancy",
"radiation",
"radiator",
"radical",
"radicalism",
"radicchio",
"radicle",
"radiculitis",
"radiigera",
"radio",
"radioactivity",
"radiobiologist",
"radiobiology",
"radiocarbon",
"radiochemist",
"radiochemistry",
"radiochlorine",
"radiogram",
"radiograph",
"radiographer",
"radiography",
"radioisotope",
"radiolaria",
"radiolarian",
"radiolocation",
"radiologist",
"radiology",
"radiolysis",
"radiometer",
"radiomicrometer",
"radiopacity",
"radiophone",
"radiophoto",
"radiophotograph",
"radioprotection",
"radioscopy",
"radiotelegraph",
"radiotelegraphy",
"radiotelephone",
"radiotelephony",
"radiotherapist",
"radiotherapy",
"radiothorium",
"radish",
"radium",
"radius",
"radix",
"radome",
"radon",
"radyera",
"raetam",
"raffia",
"raffinose",
"raffle",
"raffles",
"rafflesiaceae",
"raft",
"rafter",
"raftman",
"rafts",
"raftsman",
"ragamuffin",
"ragbag",
"rage",
"ragee",
"raggedness",
"ragi",
"raglan",
"ragnarok",
"ragout",
"ragpicker",
"ragsorter",
"ragtag",
"ragtime",
"ragusa",
"ragweed",
"ragwort",
"rahu",
"raid",
"raider",
"rail",
"railbird",
"railcar",
"railhead",
"railing",
"raillery",
"railroad",
"railroader",
"railroading",
"rails",
"railway",
"railwayman",
"railyard",
"raiment",
"rain",
"rainbow",
"raincoat",
"raindrop",
"rainfall",
"rainfly",
"rainforest",
"rainier",
"raininess",
"rainmaker",
"rainmaking",
"rainstorm",
"rainwater",
"raise",
"raiser",
"raisin",
"raising",
"raita",
"raiu",
"raja",
"rajab",
"rajah",
"rajanya",
"rajidae",
"rajiformes",
"rajpoot",
"rajput",
"rakaposhi",
"rake",
"rakehell",
"rakishness",
"rale",
"ralegh",
"raleigh",
"rallidae",
"rally",
"rallying",
"rama",
"ramachandra",
"ramadan",
"ramalina",
"ramanavami",
"ramayana",
"ramble",
"rambler",
"rambotan",
"rambouillet",
"rambutan",
"rameau",
"ramee",
"ramekin",
"ramequin",
"rameses",
"ramesses",
"ramie",
"ramification",
"ramipril",
"ramjet",
"ramman",
"rammer",
"ramona",
"ramontchi",
"ramp",
"rampage",
"rampart",
"ramphastidae",
"ramphomicron",
"rampion",
"ramrod",
"ramses",
"ramsons",
"ramus",
"rana",
"ranales",
"ranatra",
"ranch",
"rancher",
"ranching",
"rancidity",
"rancidness",
"rancor",
"rancour",
"rand",
"randomisation",
"randomization",
"randomness",
"ranee",
"range",
"rangefinder",
"rangeland",
"ranger",
"rangifer",
"rangoon",
"rangpur",
"rani",
"ranid",
"ranidae",
"ranitidine",
"rank",
"ranker",
"rankin",
"rankine",
"ranking",
"rankness",
"ransacking",
"ransom",
"rant",
"ranter",
"ranting",
"ranula",
"ranunculaceae",
"ranunculales",
"ranunculus",
"raoulia",
"rapaciousness",
"rapacity",
"rapateaceae",
"rape",
"raper",
"rapeseed",
"raphael",
"raphanus",
"raphe",
"raphia",
"raphicerus",
"raphidae",
"raphidiidae",
"raphus",
"rapid",
"rapidity",
"rapidness",
"rapier",
"rapine",
"rapist",
"rappahannock",
"rappee",
"rappel",
"rappeller",
"rapper",
"rapport",
"rapporteur",
"rapprochement",
"rapscallion",
"raptor",
"raptores",
"rapture",
"raptus",
"rarebit",
"rarefaction",
"rareness",
"rariora",
"rarity",
"rascal",
"rascality",
"rash",
"rasher",
"rashness",
"rasht",
"rask",
"raskolnikov",
"rasmussen",
"rasp",
"raspberry",
"rasping",
"rasputin",
"rassling",
"rasta",
"rastafari",
"rastafarian",
"rastafarianism",
"rastas",
"raster",
"ratability",
"ratables",
"ratafee",
"ratafia",
"ratan",
"rataplan",
"ratatouille",
"ratch",
"ratchet",
"rate",
"rateability",
"rateables",
"ratel",
"ratepayer",
"rates",
"rathole",
"rathskeller",
"ratibida",
"ratification",
"ratifier",
"rating",
"ratio",
"ratiocination",
"ratiocinator",
"ration",
"rational",
"rationale",
"rationalisation",
"rationalism",
"rationalist",
"rationality",
"rationalization",
"rationalness",
"rationing",
"ratitae",
"ratite",
"ratlin",
"ratline",
"ratsbane",
"rattail",
"rattan",
"ratter",
"rattigan",
"ratting",
"rattle",
"rattlebox",
"rattler",
"rattlesnake",
"rattling",
"rattrap",
"rattus",
"raudixin",
"raunch",
"rauvolfia",
"rauwolfia",
"ravage",
"ravaging",
"rave",
"ravehook",
"ravel",
"raveling",
"ravelling",
"raven",
"ravenala",
"ravenna",
"ravenousness",
"raver",
"ravigote",
"ravigotte",
"ravine",
"raving",
"ravioli",
"ravisher",
"ravishment",
"rawalpindi",
"rawhide",
"rawness",
"rayleigh",
"rayon",
"rayons",
"razbliuto",
"razing",
"razmataz",
"razor",
"razorback",
"razorbill",
"razorblade",
"razz",
"razzing",
"razzle",
"razzmatazz",
"rcmp",
"reabsorption",
"reach",
"reaching",
"reactance",
"reactant",
"reaction",
"reactionary",
"reactionism",
"reactivity",
"reactor",
"read",
"readability",
"reader",
"readership",
"readiness",
"reading",
"readjustment",
"readmission",
"readout",
"ready",
"readying",
"reaffiliation",
"reaffirmation",
"reagan",
"reagent",
"reagin",
"real",
"realgar",
"realisation",
"realism",
"realist",
"reality",
"realization",
"reallocation",
"reallotment",
"realm",
"realness",
"realpolitik",
"realtor",
"realty",
"ream",
"reamer",
"reaper",
"reappearance",
"reapportionment",
"reappraisal",
"rear",
"rearguard",
"rearing",
"rearmament",
"rearrangement",
"rearward",
"reason",
"reasonableness",
"reasoner",
"reasoning",
"reassembly",
"reassertion",
"reassessment",
"reassignment",
"reassurance",
"reata",
"reaumur",
"rebate",
"rebato",
"rebecca",
"rebekah",
"rebel",
"rebellion",
"rebelliousness",
"rebirth",
"rebound",
"reboxetine",
"rebozo",
"rebroadcast",
"rebuff",
"rebuilding",
"rebuke",
"rebuker",
"reburial",
"reburying",
"rebus",
"rebuttal",
"rebutter",
"recalcitrance",
"recalcitrancy",
"recalculation",
"recall",
"recantation",
"recap",
"recapitulation",
"recapture",
"recasting",
"recce",
"recco",
"reccy",
"receding",
"receipt",
"receipts",
"receivables",
"receiver",
"receivership",
"recency",
"recent",
"recentness",
"receptacle",
"reception",
"receptionist",
"receptiveness",
"receptivity",
"receptor",
"recess",
"recession",
"recessional",
"recessive",
"rechauffe",
"recidivism",
"recidivist",
"recife",
"recipe",
"recipient",
"reciprocal",
"reciprocality",
"reciprocation",
"reciprocity",
"recirculation",
"recission",
"recital",
"recitalist",
"recitation",
"recitative",
"reciter",
"recklessness",
"reckoner",
"reckoning",
"reclamation",
"recliner",
"reclining",
"recluse",
"reclusiveness",
"recoding",
"recognisance",
"recognition",
"recognizance",
"recoil",
"recollection",
"recombinant",
"recombination",
"recommencement",
"recommendation",
"recompense",
"reconciler",
"reconciliation",
"reconditeness",
"reconnaissance",
"reconnoitering",
"reconnoitring",
"reconsideration",
"reconstruction",
"record",
"recorder",
"recording",
"recount",
"recounting",
"recourse",
"recoverer",
"recovery",
"recreant",
"recreation",
"recrimination",
"recrudescence",
"recruit",
"recruiter",
"recruitment",
"rectangle",
"rectangularity",
"rectification",
"rectifier",
"rectitude",
"recto",
"rectocele",
"rectoplasty",
"rector",
"rectorate",
"rectorship",
"rectory",
"rectum",
"rectus",
"recuperation",
"recurrence",
"recursion",
"recurvirostra",
"recusal",
"recusancy",
"recusant",
"recusation",
"recycling",
"redact",
"redaction",
"redactor",
"redbelly",
"redberry",
"redbird",
"redbone",
"redbreast",
"redbrush",
"redbud",
"redbug",
"redcap",
"redcoat",
"redding",
"reddle",
"rededication",
"redeemer",
"redefinition",
"redemption",
"redeployment",
"redeposition",
"redetermination",
"redevelopment",
"redeye",
"redfish",
"redford",
"redhead",
"redheader",
"redhorse",
"rediffusion",
"rediscovery",
"redisposition",
"redistribution",
"redmaids",
"redneck",
"redness",
"redolence",
"redonda",
"redoubt",
"redox",
"redpoll",
"redraft",
"redress",
"redroot",
"redshank",
"redshift",
"redskin",
"redstart",
"redtail",
"reducer",
"reducing",
"reductant",
"reductase",
"reductio",
"reduction",
"reductionism",
"reductivism",
"redundance",
"redundancy",
"reduplication",
"reduviid",
"reduviidae",
"redwing",
"redwood",
"reed",
"reedbird",
"reedmace",
"reef",
"reefer",
"reek",
"reel",
"reelection",
"reeler",
"reenactment",
"reenactor",
"reenforcement",
"reenlistment",
"reentry",
"reevaluation",
"reeve",
"reexamination",
"refabrication",
"refection",
"refectory",
"referee",
"refereeing",
"reference",
"referendum",
"referent",
"referral",
"refill",
"refilling",
"refinement",
"refiner",
"refinery",
"refining",
"refinisher",
"refit",
"reflation",
"reflectance",
"reflection",
"reflectiveness",
"reflectivity",
"reflectometer",
"reflector",
"reflex",
"reflexion",
"reflexive",
"reflexiveness",
"reflexivity",
"reflexology",
"reflux",
"refocusing",
"reforestation",
"reform",
"reformation",
"reformatory",
"reformer",
"reformism",
"reformist",
"refraction",
"refractiveness",
"refractivity",
"refractometer",
"refractoriness",
"refractory",
"refrain",
"refresher",
"refreshment",
"refrigerant",
"refrigeration",
"refrigerator",
"refueling",
"refuge",
"refugee",
"refulgence",
"refulgency",
"refund",
"refurbishment",
"refusal",
"refuse",
"refutal",
"refutation",
"refuter",
"regaining",
"regalecidae",
"regalia",
"regard",
"regatta",
"regency",
"regeneration",
"regent",
"reggae",
"reggane",
"regicide",
"regime",
"regimen",
"regiment",
"regimentals",
"regimentation",
"regina",
"regiomontanus",
"region",
"regionalism",
"register",
"registrant",
"registrar",
"registration",
"registry",
"reglaecus",
"regnellidium",
"regosol",
"regress",
"regression",
"regret",
"regrets",
"regular",
"regularisation",
"regularity",
"regularization",
"regulating",
"regulation",
"regulator",
"regulus",
"regur",
"regurgitation",
"rehabilitation",
"reharmonisation",
"reharmonization",
"rehash",
"rehearing",
"rehearsal",
"rehnquist",
"reich",
"reichstein",
"reid",
"reification",
"reign",
"reimbursement",
"reimposition",
"reims",
"rein",
"reincarnation",
"reindeer",
"reinforcement",
"reinforcer",
"reinstatement",
"reinsurance",
"reintroduction",
"reissue",
"reit",
"reiter",
"reiteration",
"reithrodontomys",
"reject",
"rejection",
"rejoicing",
"rejoinder",
"rejuvenation",
"relafen",
"relapse",
"relapsing",
"relatedness",
"relation",
"relations",
"relationship",
"relative",
"relativism",
"relativity",
"relatum",
"relaxant",
"relaxation",
"relaxer",
"relaxin",
"relay",
"release",
"relegating",
"relegation",
"relentlessness",
"relevance",
"relevancy",
"reliability",
"reliableness",
"reliance",
"relic",
"relict",
"relief",
"reliever",
"relievo",
"religion",
"religionism",
"religionist",
"religiosity",
"religious",
"religiousism",
"religiousness",
"relinquishing",
"relinquishment",
"reliquary",
"relish",
"relishing",
"relistening",
"reliving",
"relocation",
"reluctance",
"reluctivity",
"remainder",
"remains",
"remake",
"remaking",
"remand",
"remark",
"remarriage",
"rematch",
"rembrandt",
"remediation",
"remedy",
"remembering",
"remembrance",
"remicade",
"remilegia",
"reminder",
"reminiscence",
"remise",
"remission",
"remissness",
"remit",
"remitment",
"remittal",
"remittance",
"remnant",
"remonstrance",
"remonstration",
"remora",
"remorse",
"remote",
"remoteness",
"remotion",
"remount",
"removal",
"remove",
"remover",
"remuda",
"remuneration",
"remunerator",
"remus",
"renaissance",
"renascence",
"render",
"rendering",
"rendezvous",
"rendition",
"renegade",
"renege",
"renewal",
"renin",
"rennet",
"rennin",
"reno",
"renoir",
"renouncement",
"renovation",
"renovator",
"renown",
"rensselaerite",
"rent",
"rental",
"rente",
"renter",
"rentier",
"renting",
"renunciation",
"reorder",
"reordering",
"reorganisation",
"reorganization",
"reorientation",
"reoviridae",
"reovirus",
"repair",
"repairer",
"repairman",
"reparation",
"repartee",
"repast",
"repatriate",
"repatriation",
"repayment",
"repeal",
"repeat",
"repeater",
"repeating",
"repechage",
"repellant",
"repellent",
"repentance",
"repercussion",
"repertoire",
"repertory",
"repetition",
"repetitiousness",
"repetitiveness",
"rephrasing",
"replaceability",
"replacement",
"replacing",
"replay",
"replenishment",
"repletion",
"replica",
"replication",
"reply",
"report",
"reportage",
"reporter",
"reporting",
"repose",
"repositing",
"reposition",
"repositioning",
"repository",
"repossession",
"repp",
"reprehension",
"representation",
"representative",
"represser",
"repression",
"repressor",
"reprieve",
"reprimand",
"reprint",
"reprinting",
"reprisal",
"reproach",
"reproacher",
"reprobate",
"reprobation",
"reproducer",
"reproducibility",
"reproduction",
"reproof",
"reproval",
"reprover",
"reptantia",
"reptile",
"reptilia",
"reptilian",
"republic",
"republican",
"republicanism",
"republication",
"republishing",
"repudiation",
"repugnance",
"repulse",
"repulsion",
"repulsiveness",
"repurchase",
"reputability",
"reputation",
"repute",
"request",
"requester",
"requiem",
"requiescat",
"requirement",
"requisite",
"requisiteness",
"requisition",
"requital",
"rerebrace",
"reredos",
"rerun",
"resale",
"rescission",
"rescript",
"rescriptor",
"rescue",
"rescuer",
"research",
"researcher",
"reseau",
"resection",
"reseda",
"resedaceae",
"resemblance",
"resentment",
"reserpine",
"reservation",
"reserve",
"reserves",
"reservist",
"reservoir",
"reset",
"resettlement",
"resh",
"reshipment",
"resht",
"reshuffle",
"reshuffling",
"resid",
"residence",
"residency",
"resident",
"residual",
"residue",
"residuum",
"resignation",
"resilience",
"resiliency",
"resin",
"resinoid",
"resistance",
"resister",
"resistivity",
"resistor",
"resoluteness",
"resolution",
"resolve",
"resolvent",
"resolving",
"resonance",
"resonator",
"resorcinol",
"resorption",
"resort",
"resource",
"resourcefulness",
"respect",
"respectability",
"respecter",
"respectfulness",
"respects",
"respighi",
"respiration",
"respirator",
"respite",
"resplendence",
"resplendency",
"respondent",
"responder",
"response",
"responsibility",
"responsibleness",
"responsiveness",
"rest",
"restatement",
"restaurant",
"restauranter",
"restaurateur",
"rester",
"restfulness",
"restharrow",
"restitution",
"restiveness",
"restlessness",
"restoration",
"restorative",
"restorer",
"restoril",
"restrainer",
"restraint",
"restriction",
"restrictiveness",
"restroom",
"result",
"resultant",
"resume",
"resumption",
"resurgence",
"resurrection",
"resurvey",
"resuscitation",
"resuscitator",
"resuspension",
"retail",
"retailer",
"retailing",
"retainer",
"retake",
"retaking",
"retaliation",
"retaliator",
"retama",
"retard",
"retardant",
"retardation",
"retarded",
"retardent",
"retch",
"rete",
"retem",
"retention",
"retentiveness",
"retentivity",
"rethink",
"reticence",
"reticle",
"reticulation",
"reticule",
"reticulitermes",
"reticulocyte",
"reticulum",
"retina",
"retinal",
"retinene",
"retinitis",
"retinoblastoma",
"retinol",
"retinopathy",
"retinue",
"retiree",
"retirement",
"retort",
"retraction",
"retractor",
"retraining",
"retread",
"retreat",
"retreatant",
"retreated",
"retrenchment",
"retrial",
"retribution",
"retrieval",
"retriever",
"retro",
"retrofit",
"retroflection",
"retroflexion",
"retrogression",
"retronym",
"retrophyllum",
"retrorocket",
"retrospect",
"retrospection",
"retrospective",
"retroversion",
"retrovir",
"retrovirus",
"retrovision",
"retsina",
"return",
"reuben",
"reunification",
"reunion",
"reuptake",
"revaluation",
"revealing",
"reveille",
"revel",
"revelation",
"reveler",
"reveller",
"revelry",
"revenant",
"revenge",
"revenue",
"revenuer",
"reverberance",
"reverberation",
"revere",
"reverence",
"reverend",
"reverie",
"revers",
"reversal",
"reverse",
"reversibility",
"reversible",
"reversion",
"reversioner",
"reversionist",
"reverting",
"revery",
"revetement",
"revetment",
"review",
"reviewer",
"revilement",
"revisal",
"revise",
"reviser",
"revising",
"revision",
"revisionism",
"revisionist",
"revitalisation",
"revitalization",
"revival",
"revivalism",
"revivalist",
"revivification",
"revocation",
"revoke",
"revolt",
"revolution",
"revolutionary",
"revolutionism",
"revolutionist",
"revolver",
"revue",
"revulsion",
"reward",
"rewording",
"rewrite",
"rewriter",
"rewriting",
"reyes",
"reykjavik",
"reynard",
"reynolds",
"rhabdomancer",
"rhabdomancy",
"rhabdomyoma",
"rhabdosarcoma",
"rhabdoviridae",
"rhabdovirus",
"rhadamanthus",
"rhagades",
"rhagoletis",
"rhamnaceae",
"rhamnales",
"rhamnus",
"rhaphe",
"rhapis",
"rhapsody",
"rhea",
"rheidae",
"rheiformes",
"rheims",
"rhein",
"rheinland",
"rhenish",
"rhenium",
"rheology",
"rheometer",
"rheostat",
"rhesus",
"rhetoric",
"rhetorician",
"rheum",
"rheumatic",
"rheumatism",
"rheumatologist",
"rheumatology",
"rhexia",
"rhibhus",
"rhincodon",
"rhincodontidae",
"rhine",
"rhineland",
"rhinencephalon",
"rhinestone",
"rhinion",
"rhinitis",
"rhino",
"rhinobatidae",
"rhinoceros",
"rhinocerotidae",
"rhinolophidae",
"rhinonicteris",
"rhinopathy",
"rhinophyma",
"rhinoplasty",
"rhinoptera",
"rhinorrhea",
"rhinoscope",
"rhinoscopy",
"rhinostenosis",
"rhinotermitidae",
"rhinotomy",
"rhinotracheitis",
"rhinovirus",
"rhipsalis",
"rhiptoglossa",
"rhizobiaceae",
"rhizobium",
"rhizoctinia",
"rhizoid",
"rhizome",
"rhizomorph",
"rhizophora",
"rhizophoraceae",
"rhizopod",
"rhizopoda",
"rhizopodan",
"rhizopogon",
"rhizopogonaceae",
"rhizopus",
"rhizotomy",
"rhodanthe",
"rhodes",
"rhodesia",
"rhodium",
"rhodochrosite",
"rhododendron",
"rhodolite",
"rhodomontade",
"rhodonite",
"rhodophyceae",
"rhodophyta",
"rhodopsin",
"rhodosphaera",
"rhodymenia",
"rhodymeniaceae",
"rhoeadales",
"rhomb",
"rhombencephalon",
"rhombohedron",
"rhomboid",
"rhombus",
"rhonchus",
"rhone",
"rhubarb",
"rhumb",
"rhumba",
"rhus",
"rhyacotriton",
"rhyme",
"rhymer",
"rhymester",
"rhynchocephalia",
"rhynchoelaps",
"rhyncostylis",
"rhynia",
"rhyniaceae",
"rhyolite",
"rhythm",
"rhythmicity",
"rhytidectomy",
"rhytidoplasty",
"rial",
"riata",
"ribald",
"ribaldry",
"riband",
"ribavirin",
"ribband",
"ribbing",
"ribbon",
"ribbonfish",
"ribbonwood",
"ribes",
"ribgrass",
"ribhus",
"ribier",
"riboflavin",
"ribonuclease",
"ribonucleinase",
"ribose",
"ribosome",
"ribwort",
"ricardo",
"rice",
"ricebird",
"ricegrass",
"ricer",
"rich",
"richards",
"richardson",
"richea",
"richelieu",
"riches",
"richler",
"richmond",
"richmondena",
"richness",
"richweed",
"ricin",
"ricinus",
"rick",
"rickenbacker",
"ricketiness",
"rickets",
"rickettsia",
"rickettsiaceae",
"rickettsiales",
"rickettsialpox",
"rickettsiosis",
"rickey",
"rickover",
"rickrack",
"ricksha",
"rickshaw",
"rico",
"ricochet",
"ricotta",
"ricrac",
"rictus",
"riddance",
"riddle",
"ride",
"rider",
"ridge",
"ridgel",
"ridgeline",
"ridgeling",
"ridgepole",
"ridgil",
"ridgling",
"ridicule",
"ridiculer",
"ridiculousness",
"riding",
"ridley",
"riel",
"riemann",
"riesling",
"riesman",
"rifadin",
"rifampin",
"riff",
"riffian",
"riffle",
"riffraff",
"rifle",
"riflebird",
"rifleman",
"rifling",
"rift",
"riga",
"rigamarole",
"rigatoni",
"rigel",
"rigger",
"rigging",
"right",
"righteousness",
"rightfield",
"rightfulness",
"righthander",
"rightism",
"rightist",
"rightness",
"rigidification",
"rigidifying",
"rigidity",
"rigidness",
"rigil",
"rigmarole",
"rigor",
"rigorousness",
"rigour",
"rigourousness",
"rigout",
"rijstafel",
"rijstaffel",
"rijsttaffel",
"riksmaal",
"riksmal",
"riley",
"rilievo",
"rilke",
"rill",
"rima",
"rimactane",
"rimbaud",
"rime",
"rimu",
"rind",
"rinderpest",
"ring",
"ringdove",
"ringer",
"ringgit",
"ringhals",
"ringing",
"ringleader",
"ringlet",
"ringling",
"ringmaster",
"rings",
"ringside",
"ringtail",
"ringway",
"ringworm",
"rink",
"rinkhals",
"rinse",
"rinsing",
"rioja",
"riot",
"rioter",
"rioting",
"riparia",
"ripcord",
"ripeness",
"ripening",
"riposte",
"ripper",
"ripple",
"rippling",
"ripsaw",
"riptide",
"rira",
"risc",
"rise",
"riser",
"risibility",
"rising",
"risk",
"riskiness",
"risklessness",
"risotto",
"rissa",
"rissole",
"ritalin",
"rite",
"ritonavir",
"rittenhouse",
"ritual",
"ritualism",
"ritualist",
"ritz",
"rival",
"rivalry",
"river",
"rivera",
"riverbank",
"riverbed",
"riverside",
"rivet",
"riveter",
"rivetter",
"riviera",
"rivina",
"rivulet",
"rivulus",
"riyadh",
"riyal",
"rnase",
"roach",
"road",
"roadbed",
"roadblock",
"roadbook",
"roadhog",
"roadhouse",
"roadkill",
"roadman",
"roadrunner",
"roads",
"roadside",
"roadstead",
"roadster",
"roadway",
"roadworthiness",
"roamer",
"roan",
"roanoke",
"roar",
"roarer",
"roaring",
"roast",
"roaster",
"roasting",
"robalo",
"robaxin",
"robber",
"robbery",
"robbins",
"robe",
"robert",
"roberts",
"robertson",
"robeson",
"robespierre",
"robin",
"robinia",
"robinson",
"robitussin",
"roble",
"robot",
"robotics",
"robustness",
"rocambole",
"roccella",
"roccellaceae",
"roccus",
"rocephin",
"rochambeau",
"rochester",
"rock",
"rockabilly",
"rockchuck",
"rockcress",
"rockefeller",
"rocker",
"rockers",
"rockery",
"rocket",
"rocketry",
"rockfish",
"rockfoil",
"rockford",
"rockies",
"rockiness",
"rockingham",
"rockrose",
"rockslide",
"rockweed",
"rockwell",
"rococo",
"rocroi",
"rodent",
"rodentia",
"rodeo",
"rodgers",
"rodhos",
"rodin",
"rodolia",
"rodomontade",
"roebling",
"roebuck",
"roentgen",
"roentgenium",
"roentgenogram",
"roentgenography",
"roentgenoscope",
"rofecoxib",
"rogaine",
"rogation",
"rogers",
"roget",
"rogue",
"roguery",
"roguishness",
"rohypnol",
"roisterer",
"rolaids",
"role",
"roleplaying",
"rolf",
"roll",
"rollback",
"roller",
"rollerblade",
"rollerblader",
"rollerblading",
"rolling",
"rollmops",
"rollo",
"rollover",
"rolodex",
"rolypoliness",
"roma",
"romaic",
"romaine",
"roman",
"romanal",
"romance",
"romanesque",
"romani",
"romania",
"romanian",
"romanism",
"romanoff",
"romanov",
"romans",
"romansh",
"romantic",
"romanticisation",
"romanticism",
"romanticist",
"romanticization",
"romany",
"romberg",
"rome",
"romeo",
"rommany",
"rommel",
"romneya",
"romp",
"romper",
"romulus",
"rondeau",
"rondel",
"rondelet",
"rondo",
"roneo",
"roneograph",
"rontgen",
"rood",
"roof",
"roofer",
"roofing",
"rooftop",
"rooftree",
"roofy",
"rooibos",
"rook",
"rookery",
"rookie",
"room",
"roomer",
"roomette",
"roomful",
"roomie",
"roominess",
"roommate",
"rooms",
"roomy",
"roosevelt",
"roost",
"rooster",
"root",
"rootage",
"rooter",
"rooting",
"rootlet",
"roots",
"rootstalk",
"rootstock",
"rope",
"ropebark",
"ropedancer",
"ropemaker",
"roper",
"ropewalk",
"ropewalker",
"ropeway",
"rophy",
"ropiness",
"roping",
"roquefort",
"roquette",
"roridula",
"roridulaceae",
"rorippa",
"rorqual",
"rorschach",
"rosa",
"rosacea",
"rosaceae",
"rosales",
"rosario",
"rosary",
"rose",
"roseau",
"rosebay",
"rosebud",
"rosebush",
"rosefish",
"rosehip",
"roselle",
"rosellinia",
"rosemaling",
"rosemary",
"roseola",
"rosette",
"rosewood",
"rosicrucian",
"rosicrucianism",
"rosidae",
"rosilla",
"rosin",
"rosiness",
"rosinweed",
"rosita",
"rosmarinus",
"ross",
"rossbach",
"rossetti",
"rossini",
"rostand",
"roster",
"rostock",
"rostov",
"rostrum",
"roswell",
"rota",
"rotarian",
"rotary",
"rotation",
"rotavirus",
"rotc",
"rote",
"rotenone",
"rotgut",
"roth",
"rothko",
"rothschild",
"rotifer",
"rotifera",
"rotisserie",
"rotl",
"rotogravure",
"rotor",
"rottenness",
"rottenstone",
"rotter",
"rotterdam",
"rotting",
"rottweiler",
"rotunda",
"rotundity",
"rotundness",
"rouble",
"roue",
"rouge",
"rougeberry",
"rough",
"roughage",
"roughcast",
"roughleg",
"roughneck",
"roughness",
"roughrider",
"roulade",
"rouleau",
"roulette",
"roumania",
"round",
"roundabout",
"roundedness",
"roundel",
"roundelay",
"rounder",
"rounders",
"roundhead",
"roundhouse",
"rounding",
"roundness",
"roundsman",
"roundtable",
"roundup",
"roundworm",
"rous",
"rouser",
"rousing",
"rousseau",
"roustabout",
"rout",
"route",
"routemarch",
"router",
"routine",
"roux",
"rover",
"roving",
"rowan",
"rowanberry",
"rowboat",
"rowdiness",
"rowdy",
"rowdyism",
"rowel",
"rower",
"rowing",
"rowlock",
"royal",
"royalism",
"royalist",
"royalty",
"roystonea",
"rozelle",
"rtlt",
"ruanda",
"rubato",
"rubber",
"rubberneck",
"rubbernecker",
"rubbing",
"rubbish",
"rubble",
"rubdown",
"rube",
"rubefacient",
"rubel",
"rubella",
"rubens",
"rubeola",
"rubia",
"rubiaceae",
"rubiales",
"rubicelle",
"rubicon",
"rubidium",
"rubinstein",
"ruble",
"rubor",
"rubric",
"rubus",
"ruby",
"ruck",
"rucksack",
"ruckus",
"ruction",
"rudapithecus",
"rudbeckia",
"rudd",
"rudder",
"rudderfish",
"rudderpost",
"rudderstock",
"ruddiness",
"ruddle",
"ruddles",
"rudeness",
"rudiment",
"rudiments",
"rudra",
"ruefulness",
"ruff",
"ruffian",
"ruffianism",
"ruffle",
"ruga",
"rugby",
"rugelach",
"ruggedisation",
"ruggedization",
"ruggedness",
"ruggelach",
"rugger",
"rugulah",
"ruhr",
"ruin",
"ruination",
"ruiner",
"ruining",
"rule",
"ruler",
"rulership",
"ruling",
"rumania",
"rumanian",
"rumansh",
"rumba",
"rumble",
"rumbling",
"rumen",
"rumex",
"ruminant",
"ruminantia",
"rumination",
"ruminator",
"rummage",
"rummer",
"rummy",
"rumohra",
"rumor",
"rumormonger",
"rumour",
"rumourmonger",
"rump",
"rumpelstiltskin",
"rumpus",
"rumrunner",
"runabout",
"runaway",
"runch",
"rundle",
"rundown",
"rundstedt",
"rune",
"rung",
"runnel",
"runner",
"runniness",
"running",
"runoff",
"runt",
"runtiness",
"runup",
"runway",
"runyon",
"rupee",
"rupert",
"rupiah",
"rupicapra",
"rupicola",
"ruptiliocarpon",
"rupture",
"rupturewort",
"ruralism",
"ruralist",
"rurality",
"ruritania",
"ruritanian",
"ruscaceae",
"ruscus",
"ruse",
"rush",
"rushdie",
"rusher",
"rushing",
"rushlight",
"rushmore",
"rusk",
"ruskin",
"russell",
"russet",
"russia",
"russian",
"russula",
"russulaceae",
"rust",
"rustbelt",
"rustic",
"rustication",
"rusticism",
"rusticity",
"rustiness",
"rusting",
"rustle",
"rustler",
"rustling",
"ruta",
"rutabaga",
"rutaceae",
"ruth",
"ruthenium",
"rutherford",
"rutherfordium",
"ruthfulness",
"ruthlessness",
"rutile",
"rutilus",
"rutland",
"rutledge",
"rwanda",
"rwandan",
"rydberg",
"ryegrass",
"rynchopidae",
"rynchops",
"rypticus",
"ryukyuan",
"saale",
"saame",
"saami",
"saarinen",
"saba",
"sabah",
"sabahan",
"sabal",
"sabaoth",
"sabaton",
"sabayon",
"sabbat",
"sabbatarian",
"sabbath",
"sabbatia",
"sabbatical",
"sabbatum",
"sabellian",
"saber",
"sabertooth",
"sabicu",
"sabin",
"sabine",
"sabinea",
"sable",
"sabot",
"sabotage",
"saboteur",
"sabra",
"sabre",
"sacagawea",
"sacajawea",
"saccade",
"saccharase",
"saccharide",
"saccharin",
"saccharinity",
"saccharomyces",
"saccharose",
"saccharum",
"sacco",
"saccule",
"sacculus",
"sacerdotalism",
"saceur",
"sachem",
"sachet",
"sachsen",
"sack",
"sackbut",
"sackcloth",
"sackful",
"sacking",
"saclant",
"sacque",
"sacrament",
"sacramento",
"sacredness",
"sacrifice",
"sacrificer",
"sacrilege",
"sacristan",
"sacristy",
"sacrum",
"sadat",
"saddam",
"saddhu",
"saddle",
"saddleback",
"saddlebag",
"saddlebill",
"saddlebow",
"saddlecloth",
"saddler",
"saddlery",
"sadducee",
"sade",
"sadhe",
"sadhu",
"sadism",
"sadist",
"sadleria",
"sadness",
"sadomasochism",
"sadomasochist",
"saek",
"safaqis",
"safar",
"safari",
"safe",
"safebreaker",
"safecracker",
"safeguard",
"safehold",
"safekeeping",
"safeness",
"safety",
"safflower",
"saffranine",
"saffron",
"safranin",
"safranine",
"saga",
"sagaciousness",
"sagacity",
"sagamore",
"sage",
"sagebrush",
"sagina",
"saginaw",
"sagitta",
"sagittaria",
"sagittariidae",
"sagittarius",
"sago",
"saguaro",
"sahaptin",
"sahaptino",
"sahara",
"saharan",
"sahib",
"sahuaro",
"saida",
"saiga",
"saigon",
"sail",
"sailboat",
"sailcloth",
"sailfish",
"sailing",
"sailmaker",
"sailor",
"sailplane",
"sailplaning",
"saimiri",
"sainfoin",
"saint",
"sainthood",
"saintliness",
"saintpaulia",
"saipan",
"sajama",
"sakartvelo",
"sake",
"sakharov",
"saki",
"sakkara",
"sakti",
"saktism",
"salaah",
"salaam",
"salaat",
"salability",
"salableness",
"salaciousness",
"salacity",
"salad",
"salade",
"saladin",
"salafism",
"salah",
"salai",
"salal",
"salamander",
"salamandra",
"salamandridae",
"salami",
"salary",
"salat",
"sale",
"salem",
"saleratus",
"salerno",
"saleroom",
"sales",
"salesclerk",
"salesgirl",
"saleslady",
"salesman",
"salesmanship",
"salesperson",
"salesroom",
"saleswoman",
"salian",
"salicaceae",
"salicales",
"salicornia",
"salicylate",
"salience",
"saliency",
"salient",
"salientia",
"salientian",
"salim",
"salina",
"saline",
"salinger",
"salinity",
"salinometer",
"salisbury",
"salish",
"salishan",
"saliva",
"salivation",
"salix",
"salk",
"sallet",
"sallow",
"sallowness",
"sally",
"salmacis",
"salmagundi",
"salmi",
"salmo",
"salmon",
"salmonberry",
"salmonella",
"salmonellosis",
"salmonid",
"salmonidae",
"salmwood",
"salol",
"salome",
"salomon",
"salon",
"salonica",
"salonika",
"saloon",
"salp",
"salpa",
"salpichroa",
"salpidae",
"salpiglossis",
"salpinctes",
"salpingectomy",
"salpingitis",
"salpinx",
"salsa",
"salsify",
"salsilla",
"salsola",
"salt",
"saltation",
"saltbox",
"saltbush",
"saltcellar",
"salter",
"saltine",
"saltiness",
"salting",
"saltire",
"saltpan",
"saltpeter",
"saltpetre",
"saltshaker",
"saltwater",
"saltworks",
"saltwort",
"salubriousness",
"salubrity",
"saluki",
"salutation",
"salutatorian",
"salutatory",
"salute",
"saluter",
"salvador",
"salvadora",
"salvadoraceae",
"salvadoran",
"salvadorean",
"salvadorian",
"salvage",
"salvager",
"salvation",
"salve",
"salvelinus",
"salver",
"salvia",
"salvinia",
"salviniaceae",
"salvinorin",
"salvo",
"salvor",
"salwar",
"salyut",
"salzburg",
"saman",
"samanala",
"samara",
"samarang",
"samarcand",
"samaria",
"samaritan",
"samarium",
"samarkand",
"samarskite",
"samba",
"sambar",
"sambre",
"sambuca",
"sambucus",
"sambur",
"same",
"samekh",
"sameness",
"samhita",
"sami",
"samia",
"samiel",
"samisen",
"samite",
"samizdat",
"samnite",
"samoa",
"samoan",
"samolus",
"samosa",
"samovar",
"samoyed",
"samoyede",
"samoyedic",
"sampan",
"samphire",
"sample",
"sampler",
"sampling",
"samsara",
"samson",
"samuel",
"samurai",
"sana",
"sanaa",
"sanatarium",
"sanatorium",
"sanchez",
"sanctification",
"sanctimony",
"sanction",
"sanctitude",
"sanctity",
"sanctuary",
"sanctum",
"sand",
"sandal",
"sandalwood",
"sandarac",
"sandarach",
"sandbag",
"sandbagger",
"sandbank",
"sandbar",
"sandberry",
"sandblast",
"sandblaster",
"sandbox",
"sandboy",
"sandbur",
"sandburg",
"sander",
"sanderling",
"sandfish",
"sandfly",
"sandglass",
"sandgrouse",
"sandhi",
"sandhopper",
"sandiness",
"sandlot",
"sandman",
"sandpaper",
"sandpile",
"sandpiper",
"sandpit",
"sandril",
"sands",
"sandspur",
"sandstone",
"sandstorm",
"sandwich",
"sandwichman",
"sandwort",
"saneness",
"sanfoin",
"sang",
"sangapenum",
"sangaree",
"sangay",
"sanger",
"sango",
"sangoma",
"sangraal",
"sangria",
"sanguification",
"sanguinaria",
"sanguine",
"sanguineness",
"sanguinity",
"sanhedrin",
"sanicle",
"sanicula",
"sanies",
"sanitariness",
"sanitarium",
"sanitation",
"sanitisation",
"sanitization",
"sanity",
"sannup",
"sannyasi",
"sannyasin",
"sansevieria",
"sanskrit",
"santa",
"santalaceae",
"santalales",
"santalum",
"santee",
"santiago",
"santims",
"santolina",
"santos",
"sanvitalia",
"sanyasi",
"saone",
"saphar",
"saphead",
"sapidity",
"sapidness",
"sapience",
"sapindaceae",
"sapindales",
"sapindus",
"sapir",
"sapling",
"sapodilla",
"saponaria",
"saponification",
"saponin",
"sapota",
"sapotaceae",
"sapote",
"sapper",
"sapphire",
"sapphirine",
"sapphism",
"sappho",
"sapporo",
"sapraemia",
"sapremia",
"saprobe",
"saprolegnia",
"saprolegniales",
"saprolite",
"sapropel",
"saprophyte",
"sapsago",
"sapsucker",
"sapwood",
"saqqara",
"saqqarah",
"saquinavir",
"saraband",
"saracen",
"sarafem",
"saragossa",
"sarah",
"sarajevo",
"saran",
"sarape",
"sarasota",
"sarasvati",
"saratoga",
"saratov",
"sarawak",
"sarawakian",
"sarazen",
"sarcasm",
"sarcenet",
"sarcobatus",
"sarcocephalus",
"sarcochilus",
"sarcocystidean",
"sarcocystieian",
"sarcocystis",
"sarcodes",
"sarcodina",
"sarcodine",
"sarcodinian",
"sarcoidosis",
"sarcolemma",
"sarcoma",
"sarcomere",
"sarcophaga",
"sarcophagus",
"sarcophilus",
"sarcoplasm",
"sarcoptes",
"sarcoptid",
"sarcoptidae",
"sarcorhamphus",
"sarcoscyphaceae",
"sarcosine",
"sarcosomataceae",
"sarcosome",
"sarcosporidia",
"sarcosporidian",
"sarcostemma",
"sarcostyle",
"sard",
"sarda",
"sardegna",
"sardina",
"sardine",
"sardinia",
"sardinian",
"sardinops",
"sardis",
"sardius",
"sardonyx",
"saree",
"sargasso",
"sargassum",
"sargent",
"sari",
"sarin",
"sarnoff",
"sarong",
"saroyan",
"sarpanitu",
"sarpedon",
"sarracenia",
"sarraceniaceae",
"sarraceniales",
"sars",
"sarsaparilla",
"sarsenet",
"sartor",
"sartorius",
"sartre",
"sash",
"sashay",
"sashimi",
"saskatchewan",
"saskatoon",
"sasquatch",
"sass",
"sassaby",
"sassafras",
"sassenach",
"sassing",
"satan",
"satang",
"satanism",
"satanist",
"satanophobia",
"satchel",
"satchmo",
"sateen",
"satellite",
"satiation",
"satie",
"satiety",
"satin",
"satinet",
"satinette",
"satinleaf",
"satinpod",
"satinwood",
"satire",
"satirist",
"satisfaction",
"satisfier",
"satori",
"satrap",
"satsuma",
"saturation",
"saturday",
"satureia",
"satureja",
"saturn",
"saturnalia",
"saturnia",
"saturniid",
"saturniidae",
"saturnism",
"satyagraha",
"satyr",
"satyriasis",
"satyridae",
"sauce",
"sauceboat",
"saucepan",
"saucepot",
"saucer",
"sauciness",
"saudi",
"sauerbraten",
"sauerkraut",
"sauk",
"saul",
"sauna",
"saunter",
"saunterer",
"saurel",
"sauria",
"saurian",
"saurischia",
"saurischian",
"sauromalus",
"sauropod",
"sauropoda",
"sauropodomorpha",
"sauropterygia",
"saurosuchus",
"saururaceae",
"saururus",
"saury",
"sausage",
"saussure",
"saussurea",
"saute",
"sauteing",
"sauterne",
"sauternes",
"savage",
"savageness",
"savagery",
"savanna",
"savannah",
"savant",
"savara",
"savarin",
"save",
"saveloy",
"saver",
"savin",
"saving",
"savings",
"savior",
"saviour",
"savitar",
"savonarola",
"savor",
"savoriness",
"savoring",
"savorlessness",
"savory",
"savour",
"savouring",
"savourlessness",
"savoury",
"savoy",
"savoyard",
"savvy",
"sawan",
"sawbill",
"sawbones",
"sawbuck",
"sawdust",
"sawfish",
"sawfly",
"sawhorse",
"sawm",
"sawmill",
"sawpit",
"sawtooth",
"sawwort",
"sawyer",
"saxe",
"saxegothea",
"saxhorn",
"saxicola",
"saxifraga",
"saxifragaceae",
"saxifrage",
"saxist",
"saxitoxin",
"saxon",
"saxony",
"saxophone",
"saxophonist",
"sayanci",
"sayda",
"sayeret",
"sayers",
"saying",
"sayonara",
"sayornis",
"sazerac",
"scab",
"scabbard",
"scabicide",
"scabies",
"scabiosa",
"scabious",
"scablands",
"scad",
"scads",
"scaffold",
"scaffolding",
"scag",
"scalability",
"scalage",
"scalar",
"scalawag",
"scald",
"scale",
"scalenus",
"scaler",
"scaliness",
"scaling",
"scallion",
"scallop",
"scallopine",
"scallopini",
"scallywag",
"scalp",
"scalpel",
"scalper",
"scam",
"scammer",
"scammony",
"scammonyroot",
"scamp",
"scamper",
"scampi",
"scampo",
"scan",
"scandal",
"scandalisation",
"scandalization",
"scandalmonger",
"scandalousness",
"scandentia",
"scandinavia",
"scandinavian",
"scandium",
"scanner",
"scanning",
"scansion",
"scantiness",
"scantling",
"scantness",
"scanty",
"scape",
"scapegoat",
"scapegrace",
"scaphiopus",
"scaphocephaly",
"scaphopod",
"scaphopoda",
"scaphosepalum",
"scapula",
"scapular",
"scapulary",
"scar",
"scarab",
"scarabaean",
"scarabaeid",
"scarabaeidae",
"scarabaeus",
"scaramouch",
"scaramouche",
"scarceness",
"scarcity",
"scardinius",
"scare",
"scarecrow",
"scaremonger",
"scarer",
"scarf",
"scarface",
"scarfpin",
"scaridae",
"scarlatina",
"scarlet",
"scarp",
"scartella",
"scat",
"scathe",
"scatology",
"scatophagy",
"scatter",
"scatterbrain",
"scattergood",
"scattergun",
"scattering",
"scaup",
"scauper",
"scavenger",
"sceliphron",
"sceloglaux",
"sceloporus",
"scenario",
"scenarist",
"scene",
"scenery",
"sceneshifter",
"scent",
"scepter",
"sceptic",
"scepticism",
"sceptre",
"scet",
"schadenfreude",
"schaffneria",
"schedule",
"scheduler",
"scheduling",
"scheele",
"scheelite",
"schefflera",
"scheldt",
"schema",
"schematic",
"schematisation",
"schematization",
"scheme",
"schemer",
"schemozzle",
"schenectady",
"scheol",
"scherzo",
"schiaparelli",
"schiller",
"schilling",
"schinus",
"schipperke",
"schism",
"schist",
"schistorrhachis",
"schistosoma",
"schistosome",
"schistosomiasis",
"schizachyrium",
"schizaea",
"schizaeaceae",
"schizanthus",
"schizocarp",
"schizogony",
"schizoid",
"schizomycetes",
"schizopetalon",
"schizophragma",
"schizophrenia",
"schizophrenic",
"schizophyceae",
"schizophyta",
"schizopoda",
"schizothymia",
"schleiden",
"schlemiel",
"schlep",
"schlepper",
"schlesien",
"schlesinger",
"schliemann",
"schlimazel",
"schlock",
"schlockmeister",
"schlumbergera",
"schmaltz",
"schmalz",
"schmear",
"schmeer",
"schmegegge",
"schmidt",
"schmo",
"schmoose",
"schmooze",
"schmoozer",
"schmuck",
"schnabel",
"schnapps",
"schnaps",
"schnauzer",
"schnecken",
"schnittlaugh",
"schnitzel",
"schnook",
"schnorchel",
"schnorkel",
"schnorrer",
"schnoz",
"schnozzle",
"schoenberg",
"scholar",
"scholarship",
"scholastic",
"scholasticism",
"scholia",
"scholiast",
"scholium",
"schomburgkia",
"schonbein",
"schonberg",
"school",
"schoolbag",
"schoolbook",
"schoolboy",
"schoolchild",
"schoolcraft",
"schooldays",
"schoolfellow",
"schoolfriend",
"schoolgirl",
"schoolhouse",
"schooling",
"schoolman",
"schoolmarm",
"schoolmaster",
"schoolmate",
"schoolmistress",
"schoolroom",
"schoolteacher",
"schooltime",
"schoolwork",
"schoolyard",
"schooner",
"schopenhauer",
"schorl",
"schottische",
"schrod",
"schrodinger",
"schtick",
"schtickl",
"schtik",
"schtikl",
"schubert",
"schulz",
"schumann",
"schumpeter",
"schutzstaffel",
"schwa",
"schwann",
"schwarzwald",
"schweitzer",
"schweiz",
"sciadopityaceae",
"sciadopitys",
"sciaena",
"sciaenid",
"sciaenidae",
"sciaenops",
"sciara",
"sciarid",
"sciaridae",
"sciatica",
"scid",
"science",
"scientist",
"scientology",
"scilla",
"scimitar",
"scincella",
"scincid",
"scincidae",
"scincus",
"scindapsus",
"scintilla",
"scintillation",
"sciolism",
"sciolist",
"scion",
"scipio",
"scirpus",
"scission",
"scissors",
"scissortail",
"scissure",
"sciuridae",
"sciuromorpha",
"sciurus",
"sclaff",
"sclera",
"scleranthus",
"scleredema",
"sclerite",
"scleritis",
"scleroderma",
"sclerometer",
"scleropages",
"scleroparei",
"scleroprotein",
"sclerosis",
"sclerotinia",
"sclerotiniaceae",
"sclerotium",
"sclerotomy",
"sclk",
"scnt",
"scoff",
"scoffer",
"scoffing",
"scofflaw",
"scoke",
"scold",
"scolder",
"scolding",
"scolion",
"scoliosis",
"scollop",
"scolopacidae",
"scolopax",
"scolopendrium",
"scolymus",
"scolytidae",
"scolytus",
"scomber",
"scomberesocidae",
"scomberesox",
"scomberomorus",
"scombresocidae",
"scombresox",
"scombridae",
"scombroid",
"scombroidea",
"sconce",
"scone",
"scoop",
"scoopful",
"scooter",
"scope",
"scopes",
"scophthalmus",
"scopolamine",
"scopolia",
"scorbutus",
"scorch",
"scorcher",
"score",
"scoreboard",
"scorecard",
"scorekeeper",
"scorer",
"scores",
"scoria",
"scoring",
"scorn",
"scorner",
"scorpaena",
"scorpaenid",
"scorpaenidae",
"scorpaenoid",
"scorpaenoidea",
"scorper",
"scorpio",
"scorpion",
"scorpionfish",
"scorpionida",
"scorpionweed",
"scorpius",
"scorsese",
"scorzonera",
"scot",
"scotch",
"scotchman",
"scotchwoman",
"scoter",
"scotland",
"scotoma",
"scots",
"scotsman",
"scotswoman",
"scott",
"scottie",
"scottish",
"scoundrel",
"scour",
"scourer",
"scourge",
"scourger",
"scouring",
"scours",
"scouse",
"scouser",
"scout",
"scouter",
"scouting",
"scoutmaster",
"scow",
"scowl",
"scpo",
"scrabble",
"scrag",
"scramble",
"scrambler",
"scranton",
"scrap",
"scrapbook",
"scrape",
"scraper",
"scrapheap",
"scrapie",
"scraping",
"scrapper",
"scrappiness",
"scrapple",
"scraps",
"scratch",
"scratcher",
"scratchiness",
"scratching",
"scratchpad",
"scrawl",
"scrawler",
"scrawniness",
"scream",
"screamer",
"screaming",
"scree",
"screech",
"screecher",
"screeching",
"screed",
"screen",
"screener",
"screening",
"screenland",
"screenplay",
"screenwriter",
"screw",
"screwball",
"screwballer",
"screwbean",
"screwdriver",
"screwing",
"screwtop",
"screwup",
"scriabin",
"scribble",
"scribbler",
"scribe",
"scriber",
"scrim",
"scrimmage",
"scrimshanker",
"scrimshaw",
"scrip",
"scripps",
"script",
"scriptorium",
"scripture",
"scriptwriter",
"scrivener",
"scrod",
"scrofula",
"scroll",
"scrooge",
"scrophularia",
"scrophulariales",
"scrotum",
"scrounger",
"scrub",
"scrubber",
"scrubbiness",
"scrubbing",
"scrubbird",
"scrubland",
"scrubs",
"scruff",
"scrum",
"scrummage",
"scrumpy",
"scrunch",
"scruple",
"scruples",
"scrupulousness",
"scrutineer",
"scrutiniser",
"scrutinizer",
"scrutiny",
"scsi",
"scuba",
"scud",
"scudding",
"scuff",
"scuffer",
"scuffle",
"scull",
"sculler",
"scullery",
"sculling",
"scullion",
"sculpin",
"sculptor",
"sculptress",
"sculpture",
"sculpturer",
"scum",
"scumble",
"scunner",
"scup",
"scupper",
"scuppernong",
"scurf",
"scurrility",
"scurry",
"scurvy",
"scut",
"scutcheon",
"scute",
"scutellaria",
"scutigera",
"scutigerella",
"scutigeridae",
"scuttle",
"scuttlebutt",
"scyliorhinidae",
"scylla",
"scyphozoa",
"scyphozoan",
"scyphus",
"scythe",
"scythia",
"scythian",
"seabag",
"seabed",
"seabird",
"seaboard",
"seaborg",
"seaborgium",
"seacoast",
"seafarer",
"seafaring",
"seafood",
"seafowl",
"seafront",
"seagrass",
"seagull",
"seahorse",
"seal",
"sealant",
"sealer",
"sealing",
"sealskin",
"sealyham",
"seam",
"seaman",
"seamanship",
"seamount",
"seamster",
"seamstress",
"seanad",
"seance",
"seaplane",
"seaport",
"seaquake",
"search",
"searcher",
"searchlight",
"searobin",
"seascape",
"seashell",
"seashore",
"seasickness",
"seaside",
"seasnail",
"season",
"seasonableness",
"seasonal",
"seasoner",
"seasoning",
"seat",
"seatbelt",
"seating",
"seats",
"seattle",
"seawall",
"seaward",
"seawater",
"seaway",
"seaweed",
"seaworthiness",
"sebastiana",
"sebastodes",
"sebastopol",
"sebe",
"seborrhea",
"sebs",
"sebum",
"secale",
"secant",
"secateurs",
"secernment",
"secession",
"secessionism",
"secessionist",
"sechuana",
"seckel",
"seclusion",
"secobarbital",
"seconal",
"second",
"secondary",
"seconder",
"secondment",
"secondo",
"secotiaceae",
"secotiales",
"secpar",
"secrecy",
"secret",
"secretaire",
"secretariat",
"secretariate",
"secretary",
"secretaryship",
"secretase",
"secreter",
"secretin",
"secretion",
"secretiveness",
"secretor",
"sect",
"sectarian",
"sectarianism",
"sectarist",
"sectary",
"section",
"sectional",
"sectionalism",
"sector",
"sectral",
"secular",
"secularisation",
"secularism",
"secularist",
"secularization",
"secundigravida",
"secureness",
"securer",
"security",
"sedalia",
"sedan",
"sedateness",
"sedation",
"sedative",
"seder",
"sedge",
"sediment",
"sedimentation",
"sedition",
"sedna",
"seducer",
"seduction",
"seductress",
"sedulity",
"sedulousness",
"sedum",
"seed",
"seedbed",
"seedcake",
"seedcase",
"seeder",
"seediness",
"seedling",
"seedman",
"seedpod",
"seedsman",
"seedtime",
"seeger",
"seeing",
"seek",
"seeker",
"seeking",
"seeland",
"seemliness",
"seepage",
"seer",
"seersucker",
"seesaw",
"segal",
"segment",
"segmentation",
"segno",
"segovia",
"segregate",
"segregation",
"segregationism",
"segregationist",
"segregator",
"segue",
"segway",
"seiche",
"seidel",
"seigneur",
"seigneury",
"seignior",
"seigniorage",
"seigniory",
"seine",
"seism",
"seismogram",
"seismograph",
"seismography",
"seismologist",
"seismology",
"seismosaur",
"seismosaurus",
"seiurus",
"seizer",
"seizing",
"seizure",
"sekhet",
"selachian",
"selachii",
"selaginella",
"selaginellaceae",
"selaginellales",
"selangor",
"selar",
"selcraig",
"selection",
"selectivity",
"selectman",
"selector",
"selectwoman",
"selenarctos",
"selene",
"selenicereus",
"selenipedium",
"selenium",
"selenolatry",
"selenology",
"seles",
"seleucus",
"self",
"selfishness",
"selflessness",
"selfsameness",
"seljuk",
"selkirk",
"selkup",
"sell",
"seller",
"sellers",
"selling",
"selloff",
"sellotape",
"sellout",
"selma",
"selsyn",
"seltzer",
"selva",
"selvage",
"selvedge",
"selznick",
"semanticist",
"semantics",
"semaphore",
"semarang",
"semasiology",
"semblance",
"semen",
"semester",
"semi",
"semiautomatic",
"semibreve",
"semicentenary",
"semicentennial",
"semicircle",
"semicolon",
"semicoma",
"semiconductor",
"semidarkness",
"semidesert",
"semidiameter",
"semiepiphyte",
"semifinal",
"semifinalist",
"semifluidity",
"semigloss",
"semimonthly",
"seminar",
"seminarian",
"seminarist",
"seminary",
"seminole",
"seminoma",
"semiology",
"semiotician",
"semiotics",
"semiparasite",
"semipro",
"semiquaver",
"semite",
"semitic",
"semitone",
"semitrailer",
"semitrance",
"semitropics",
"semivowel",
"semiweekly",
"semolina",
"sempach",
"sempiternity",
"sempstress",
"senate",
"senator",
"senatorship",
"sendee",
"sender",
"sending",
"sendup",
"sene",
"seneca",
"senecio",
"senefelder",
"senega",
"senegal",
"senegalese",
"senescence",
"seneschal",
"senhor",
"senility",
"senior",
"seniority",
"seniti",
"senna",
"sennacherib",
"sennenhunde",
"sennett",
"sennit",
"senor",
"senora",
"senorita",
"sens",
"sensation",
"sensationalism",
"sensationalist",
"sense",
"senselessness",
"sensibility",
"sensibleness",
"sensing",
"sensitisation",
"sensitiser",
"sensitising",
"sensitive",
"sensitiveness",
"sensitivity",
"sensitization",
"sensitizer",
"sensitizing",
"sensitometer",
"sensor",
"sensorium",
"sensualism",
"sensualist",
"sensuality",
"sensualness",
"sensuousness",
"sent",
"sente",
"sentence",
"sentience",
"sentiency",
"sentiment",
"sentimentalism",
"sentimentalist",
"sentimentality",
"sentinel",
"sentry",
"seoul",
"sepal",
"separability",
"separate",
"separateness",
"separation",
"separationism",
"separationist",
"separatism",
"separatist",
"separator",
"separatrix",
"sephardi",
"sepia",
"sepiidae",
"sepiolite",
"seppuku",
"sepsis",
"sept",
"septation",
"septectomy",
"september",
"septenary",
"septet",
"septette",
"septicaemia",
"septicemia",
"septillion",
"septobasidium",
"septuagenarian",
"septuagesima",
"septuagint",
"septum",
"sepulcher",
"sepulchre",
"sepulture",
"sequel",
"sequela",
"sequella",
"sequenator",
"sequence",
"sequencer",
"sequestration",
"sequin",
"sequoia",
"sequoiadendron",
"sequoya",
"sequoyah",
"seraglio",
"serail",
"serape",
"seraph",
"serax",
"serb",
"serbia",
"serbian",
"serdica",
"serenade",
"serendipity",
"sereness",
"serengeti",
"serenity",
"serenoa",
"serer",
"serf",
"serfdom",
"serfhood",
"serge",
"sergeant",
"serger",
"serial",
"serialisation",
"serialism",
"serialization",
"sericocarpus",
"sericterium",
"serictery",
"sericulture",
"sericulturist",
"seriema",
"series",
"serif",
"serigraph",
"serigraphy",
"serin",
"serine",
"serinus",
"seriocomedy",
"seriola",
"seriousness",
"seriph",
"seriphidium",
"seriphus",
"serjeant",
"serkin",
"sermon",
"sermoniser",
"sermonizer",
"serologist",
"serology",
"serosa",
"serotine",
"serotonin",
"serow",
"serpasil",
"serpens",
"serpent",
"serpentes",
"serra",
"serranid",
"serranidae",
"serranus",
"serrasalmus",
"serratia",
"serration",
"serratula",
"serratus",
"sertraline",
"sertularia",
"sertularian",
"serum",
"serval",
"servant",
"serve",
"server",
"service",
"serviceability",
"serviceableness",
"serviceberry",
"serviceman",
"services",
"servicing",
"serviette",
"servility",
"serving",
"servitor",
"servitude",
"servo",
"servomechanism",
"servosystem",
"serzone",
"sesame",
"sesamoid",
"sesamum",
"sesbania",
"seseli",
"sesotho",
"sesquipedalia",
"sesquipedalian",
"sesquipedality",
"sess",
"session",
"sessions",
"sestet",
"seta",
"setaria",
"setback",
"seth",
"setline",
"setoff",
"seton",
"setophaga",
"setscrew",
"setswana",
"sett",
"settee",
"setter",
"setterwort",
"setting",
"settle",
"settlement",
"settler",
"settling",
"settlings",
"settlor",
"setubal",
"setup",
"seurat",
"sevastopol",
"seven",
"sevener",
"sevens",
"sevensome",
"seventeen",
"seventeenth",
"seventh",
"seventies",
"seventieth",
"seventy",
"severalty",
"severance",
"severeness",
"severing",
"severity",
"severn",
"sevilla",
"seville",
"sewage",
"seward",
"sewellel",
"sewer",
"sewerage",
"sewing",
"sexagenarian",
"sexcapade",
"sexiness",
"sexism",
"sexist",
"sexlessness",
"sexploitation",
"sexpot",
"sext",
"sextant",
"sextet",
"sextette",
"sextillion",
"sexton",
"sextuplet",
"sexuality",
"seychelles",
"seychellois",
"seyhan",
"seymour",
"sezession",
"sfax",
"sforzando",
"sgml",
"sgraffito",
"shaaban",
"shabbiness",
"shabu",
"shabuoth",
"shack",
"shackle",
"shad",
"shadberry",
"shadblow",
"shadbush",
"shaddock",
"shade",
"shades",
"shadflower",
"shadfly",
"shadiness",
"shading",
"shadow",
"shadowboxing",
"shadower",
"shadowgraph",
"shadowiness",
"shadowing",
"shaft",
"shag",
"shagbark",
"shagginess",
"shaggymane",
"shah",
"shahadah",
"shahaptian",
"shaheed",
"shahn",
"shaitan",
"shake",
"shakedown",
"shakeout",
"shaker",
"shakers",
"shakespeare",
"shakespearean",
"shakespearian",
"shakeup",
"shakiness",
"shaking",
"shako",
"shakspere",
"shakti",
"shaktism",
"shaktist",
"shale",
"shallon",
"shallot",
"shallow",
"shallowness",
"shallu",
"shalwar",
"sham",
"shaman",
"shamanism",
"shamash",
"shamble",
"shambles",
"shambling",
"shame",
"shamefacedness",
"shamefulness",
"shamelessness",
"shamisen",
"shammer",
"shammy",
"shampoo",
"shamrock",
"shamus",
"shan",
"shandy",
"shandygaff",
"shang",
"shanghai",
"shanghaier",
"shank",
"shankar",
"shannon",
"shanny",
"shantung",
"shanty",
"shantytown",
"shape",
"shapelessness",
"shapeliness",
"shaper",
"shaping",
"shapley",
"shard",
"share",
"sharecropper",
"shareholder",
"shareholding",
"shareowner",
"sharer",
"shareware",
"shari",
"sharia",
"shariah",
"sharing",
"shark",
"sharkskin",
"sharksucker",
"sharp",
"sharpener",
"sharper",
"sharpie",
"sharpness",
"sharpshooter",
"sharpy",
"shasta",
"shastan",
"shattering",
"shave",
"shaver",
"shavian",
"shaving",
"shavous",
"shavuot",
"shavuoth",
"shaw",
"shawl",
"shawm",
"shawn",
"shawnee",
"shawny",
"shawwal",
"shay",
"shaytan",
"sheaf",
"shear",
"shearer",
"shearing",
"shears",
"shearwater",
"sheatfish",
"sheath",
"sheathing",
"shebang",
"shebat",
"shebeen",
"shed",
"shedder",
"shedding",
"sheen",
"sheeny",
"sheep",
"sheepcote",
"sheepdog",
"sheepfold",
"sheepherder",
"sheepishness",
"sheepman",
"sheeprun",
"sheepshank",
"sheepshead",
"sheepshearing",
"sheepskin",
"sheepwalk",
"sheesha",
"sheet",
"sheeting",
"sheetrock",
"sheffield",
"shegetz",
"sheik",
"sheika",
"sheikdom",
"sheikh",
"sheikha",
"sheikhdom",
"shekel",
"shekels",
"sheldrake",
"shelduck",
"shelf",
"shelfful",
"shell",
"shellac",
"shellbark",
"sheller",
"shelley",
"shellfire",
"shellfish",
"shellflower",
"shelling",
"shelter",
"shelterbelt",
"shelver",
"shem",
"shema",
"shemozzle",
"shenanigan",
"shenyang",
"shepard",
"shepherd",
"shepherdess",
"sheraton",
"sherbert",
"sherbet",
"sherd",
"sheridan",
"sheriff",
"sherlock",
"sherman",
"sherpa",
"sherrington",
"sherry",
"sherwood",
"shetland",
"shevat",
"shevchenko",
"shia",
"shiah",
"shiatsu",
"shibah",
"shibboleth",
"shield",
"shielder",
"shielding",
"shift",
"shifter",
"shiftiness",
"shifting",
"shiftlessness",
"shigella",
"shigellosis",
"shiism",
"shiitake",
"shiite",
"shikoku",
"shiksa",
"shikse",
"shill",
"shillalah",
"shillelagh",
"shilling",
"shillyshally",
"shiloh",
"shim",
"shimmer",
"shimmy",
"shin",
"shina",
"shinbone",
"shindig",
"shindy",
"shine",
"shiner",
"shingle",
"shingler",
"shingles",
"shingling",
"shingon",
"shininess",
"shining",
"shinleaf",
"shinney",
"shinny",
"shinpad",
"shinplaster",
"shinto",
"shintoism",
"shintoist",
"ship",
"shipbuilder",
"shipbuilding",
"shipload",
"shipmate",
"shipment",
"shipowner",
"shipper",
"shipping",
"shipside",
"shipway",
"shipworm",
"shipwreck",
"shipwright",
"shipyard",
"shiraz",
"shire",
"shirer",
"shirker",
"shirking",
"shirring",
"shirt",
"shirtdress",
"shirtfront",
"shirting",
"shirtmaker",
"shirtsleeve",
"shirtsleeves",
"shirttail",
"shirtwaist",
"shirtwaister",
"shisha",
"shit",
"shite",
"shithead",
"shitlist",
"shittah",
"shitter",
"shittim",
"shittimwood",
"shitting",
"shitwork",
"shiv",
"shiva",
"shivah",
"shivaism",
"shivaist",
"shivaree",
"shiver",
"shivering",
"shlemiel",
"shlep",
"shlepper",
"shlimazel",
"shlock",
"shlockmeister",
"shmaltz",
"shmear",
"shmegegge",
"shmo",
"shmooze",
"shmuck",
"shnook",
"shnorrer",
"shoal",
"shoat",
"shock",
"shocker",
"shockley",
"shoddiness",
"shoddy",
"shoe",
"shoebill",
"shoebird",
"shoeblack",
"shoebox",
"shoeful",
"shoehorn",
"shoelace",
"shoemaker",
"shoemaking",
"shoes",
"shoeshine",
"shoestring",
"shoetree",
"shofar",
"shogi",
"shogun",
"shogunate",
"shoji",
"shona",
"shoofly",
"shook",
"shoot",
"shooter",
"shooting",
"shootout",
"shop",
"shopaholic",
"shopfront",
"shophar",
"shopkeeper",
"shoplifter",
"shoplifting",
"shopper",
"shopping",
"shopwalker",
"shopwindow",
"shore",
"shorea",
"shorebird",
"shoreline",
"shoring",
"short",
"shortage",
"shortbread",
"shortcake",
"shortcoming",
"shortcut",
"shortener",
"shortening",
"shortfall",
"shortgrass",
"shorthand",
"shorthorn",
"shortia",
"shortlist",
"shortness",
"shorts",
"shortstop",
"shoshone",
"shoshonean",
"shoshoni",
"shoshonian",
"shostakovich",
"shot",
"shote",
"shotgun",
"shoulder",
"shout",
"shouter",
"shouting",
"shove",
"shovel",
"shovelboard",
"shoveler",
"shovelful",
"shovelhead",
"shoveller",
"shover",
"show",
"showboat",
"showcase",
"showdown",
"shower",
"showerhead",
"showgirl",
"showiness",
"showing",
"showjumping",
"showman",
"showmanship",
"showpiece",
"showplace",
"showroom",
"showstopper",
"showtime",
"shrapnel",
"shred",
"shredder",
"shreveport",
"shrew",
"shrewdness",
"shrewishness",
"shrewmouse",
"shriek",
"shrieking",
"shrift",
"shrike",
"shrilling",
"shrillness",
"shrimp",
"shrimper",
"shrimpfish",
"shrine",
"shrink",
"shrinkage",
"shrinking",
"shroud",
"shrovetide",
"shrub",
"shrubbery",
"shrublet",
"shrug",
"shtick",
"shtickl",
"shtik",
"shtikl",
"shtup",
"shua",
"shuck",
"shucks",
"shudder",
"shudra",
"shuffle",
"shuffleboard",
"shuffler",
"shuffling",
"shufti",
"shumac",
"shunning",
"shunt",
"shunter",
"shutdown",
"shute",
"shuteye",
"shutout",
"shutter",
"shutterbug",
"shutting",
"shuttle",
"shuttlecock",
"shwa",
"shylock",
"shyness",
"shyster",
"sial",
"sialadenitis",
"sialia",
"sialidae",
"sialis",
"sialolith",
"siam",
"siamang",
"siamese",
"sian",
"sibelius",
"siberia",
"siberian",
"sibilant",
"sibilation",
"sibine",
"sibling",
"sibyl",
"siccative",
"sichuan",
"sicilia",
"sicilian",
"sicily",
"sick",
"sickbag",
"sickbay",
"sickbed",
"sickeningness",
"sickle",
"sicklepod",
"sickness",
"sickroom",
"sida",
"sidalcea",
"siddhartha",
"siddons",
"side",
"sidebar",
"sideboard",
"sideburn",
"sidecar",
"sidekick",
"sidelight",
"sideline",
"siderite",
"sideritis",
"sideroblast",
"siderocyte",
"sideropenia",
"siderophilin",
"siderosis",
"sidesaddle",
"sideshow",
"sideslip",
"sidesman",
"sidesplitter",
"sidestep",
"sidestroke",
"sideswipe",
"sidetrack",
"sidewalk",
"sidewall",
"sidewinder",
"siding",
"sidney",
"sidon",
"sids",
"siege",
"siegfried",
"siemens",
"sienna",
"sierra",
"siesta",
"sieve",
"sifter",
"sifting",
"sigeh",
"sigh",
"sight",
"sightedness",
"sighting",
"sightlessness",
"sightreader",
"sights",
"sightseeing",
"sightseer",
"sigint",
"sigma",
"sigmodon",
"sigmoidectomy",
"sigmoidoscope",
"sigmoidoscopy",
"sign",
"signage",
"signal",
"signaler",
"signaling",
"signalisation",
"signalization",
"signaller",
"signalman",
"signatory",
"signature",
"signboard",
"signer",
"signet",
"significance",
"signification",
"signified",
"signifier",
"signing",
"signior",
"signor",
"signora",
"signore",
"signorina",
"signory",
"signpost",
"sigurd",
"sigyn",
"sihasapa",
"sika",
"sikh",
"sikhism",
"sikkim",
"sikorsky",
"silage",
"sild",
"sildenafil",
"silence",
"silencer",
"silene",
"silents",
"silenus",
"silesia",
"silex",
"silhouette",
"silica",
"silicate",
"silicide",
"silicle",
"silicon",
"silicone",
"silicosis",
"siliqua",
"silique",
"silk",
"silkgrass",
"silkiness",
"silks",
"silkscreen",
"silkweed",
"silkwood",
"silkworm",
"sill",
"sillabub",
"sillaginidae",
"sillago",
"silliness",
"sills",
"silly",
"silo",
"siloxane",
"silphium",
"silt",
"siltstone",
"silurian",
"silurid",
"siluridae",
"siluriformes",
"silurus",
"silva",
"silvan",
"silvanus",
"silver",
"silverback",
"silverberry",
"silverbush",
"silverfish",
"silverpoint",
"silverrod",
"silverside",
"silversides",
"silversmith",
"silverspot",
"silverstein",
"silversword",
"silvertip",
"silvervine",
"silverware",
"silverweed",
"silverwork",
"silverworker",
"silvex",
"silvia",
"silviculture",
"silybum",
"sima",
"simal",
"simarouba",
"simaroubaceae",
"simazine",
"simenon",
"simeon",
"simian",
"similarity",
"simile",
"similitude",
"simmer",
"simmering",
"simmpleness",
"simnel",
"simoleons",
"simon",
"simoniz",
"simony",
"simoom",
"simoon",
"simper",
"simperer",
"simple",
"simpleness",
"simpleton",
"simplicity",
"simplification",
"simplism",
"simpson",
"simulacrum",
"simulation",
"simulator",
"simulcast",
"simuliidae",
"simulium",
"simultaneity",
"simvastatin",
"sinai",
"sinanthropus",
"sinapis",
"sinapism",
"sinatra",
"sinbad",
"sincerity",
"sinciput",
"sinclair",
"sind",
"sindhi",
"sine",
"sinecure",
"sinequan",
"sinew",
"sinfulness",
"singalong",
"singan",
"singapore",
"singaporean",
"singe",
"singer",
"singhalese",
"singing",
"single",
"singleness",
"singles",
"singlestick",
"singlet",
"singleton",
"singsong",
"singular",
"singularity",
"singultus",
"sinhala",
"sinhalese",
"sinistrality",
"sinitic",
"sink",
"sinker",
"sinkhole",
"sinkiang",
"sinking",
"sinlessness",
"sinner",
"sinning",
"sinningia",
"sinologist",
"sinology",
"sinoper",
"sinopia",
"sinopis",
"sinornis",
"sinuosity",
"sinuousness",
"sinus",
"sinusitis",
"sinusoid",
"sion",
"siouan",
"sioux",
"siphon",
"siphonaptera",
"siphonophora",
"siphonophore",
"sipper",
"sipuncula",
"sipunculid",
"siqueiros",
"sirach",
"siracusa",
"sirc",
"sirdar",
"sire",
"siren",
"sirenia",
"sirenian",
"sirenidae",
"siriasis",
"siris",
"sirius",
"sirloin",
"sirocco",
"sirrah",
"sirup",
"sisal",
"sise",
"sisham",
"siskin",
"sison",
"sissiness",
"sissoo",
"sissu",
"sissy",
"sister",
"sisterhood",
"sistership",
"sistrurus",
"sisyphus",
"sisyridae",
"sisyrinchium",
"sita",
"sitar",
"sitcom",
"site",
"sitka",
"sitophylus",
"sitotroga",
"sitsang",
"sitta",
"sitter",
"sittidae",
"sitting",
"situation",
"sitwell",
"sium",
"siva",
"sivaism",
"sivan",
"sivapithecus",
"siwan",
"sixer",
"sixpack",
"sixpence",
"sixsome",
"sixteen",
"sixteenth",
"sixth",
"sixties",
"sixtieth",
"sixty",
"size",
"sizeableness",
"sizing",
"sizzle",
"sjaelland",
"skag",
"skagerak",
"skagerrak",
"skagit",
"skagway",
"skanda",
"skank",
"skate",
"skateboard",
"skateboarder",
"skateboarding",
"skater",
"skating",
"skaw",
"skeat",
"skedaddle",
"skeet",
"skeg",
"skein",
"skeleton",
"skep",
"skepful",
"skeptic",
"skepticism",
"sketch",
"sketchbook",
"sketcher",
"sketchiness",
"skewer",
"skewness",
"skiagram",
"skiagraph",
"skiagraphy",
"skibob",
"skid",
"skidder",
"skidpan",
"skier",
"skiff",
"skiffle",
"skiing",
"skill",
"skillet",
"skilletfish",
"skillfulness",
"skilly",
"skim",
"skimmer",
"skimming",
"skin",
"skincare",
"skinflint",
"skinful",
"skinhead",
"skinheads",
"skink",
"skinner",
"skinnerian",
"skinniness",
"skinny",
"skip",
"skipjack",
"skipper",
"skirl",
"skirmish",
"skirmisher",
"skirret",
"skirt",
"skit",
"skittishness",
"skittle",
"skittles",
"skivvies",
"skivvy",
"skopje",
"skoplje",
"skua",
"skuld",
"skulduggery",
"skulker",
"skulking",
"skull",
"skullcap",
"skullduggery",
"skunk",
"skunkbush",
"skunkweed",
"skybox",
"skycap",
"skydiver",
"skydiving",
"skyhook",
"skylab",
"skylark",
"skylight",
"skyline",
"skyrocket",
"skysail",
"skyscraper",
"skywalk",
"skyway",
"skywriting",
"slab",
"slack",
"slackening",
"slacker",
"slacking",
"slackness",
"slacks",
"slag",
"slagheap",
"slain",
"slalom",
"slam",
"slammer",
"slander",
"slanderer",
"slang",
"slanginess",
"slanguage",
"slant",
"slap",
"slapper",
"slapshot",
"slapstick",
"slash",
"slasher",
"slask",
"slat",
"slate",
"slater",
"slating",
"slattern",
"slatternliness",
"slaughter",
"slaughterer",
"slaughterhouse",
"slav",
"slave",
"slaveholder",
"slaveholding",
"slaver",
"slavery",
"slavey",
"slavic",
"slavonic",
"slaw",
"slayer",
"slaying",
"sleaze",
"sleaziness",
"sled",
"sledder",
"sledding",
"sledge",
"sledgehammer",
"sleekness",
"sleep",
"sleeper",
"sleepiness",
"sleeping",
"sleeplessness",
"sleepover",
"sleepwalker",
"sleepwalking",
"sleepwear",
"sleepyhead",
"sleet",
"sleeve",
"sleigh",
"sleight",
"slenderness",
"sleuth",
"sleuthhound",
"sleuthing",
"slew",
"slews",
"slezsko",
"slice",
"slicer",
"slicing",
"slick",
"slicker",
"slickness",
"slide",
"slider",
"slideway",
"slight",
"slightness",
"slime",
"sliminess",
"slimness",
"sling",
"slingback",
"slinger",
"slinging",
"slingshot",
"slip",
"slipcover",
"slipknot",
"slipover",
"slippage",
"slipper",
"slipperiness",
"slipperwort",
"slipstick",
"slipstream",
"slipway",
"slit",
"sliver",
"slivovitz",
"sloanea",
"slob",
"slobber",
"slobberer",
"sloe",
"slogan",
"sloganeer",
"sloganeering",
"slogger",
"sloop",
"slop",
"slope",
"sloppiness",
"slops",
"slopseller",
"slopshop",
"slot",
"sloth",
"slothfulness",
"slouch",
"sloucher",
"slough",
"sloughing",
"slovak",
"slovakia",
"sloven",
"slovene",
"slovenia",
"slovenian",
"slovenija",
"slovenliness",
"slowcoach",
"slowdown",
"slowing",
"slowness",
"slowpoke",
"slowworm",
"slub",
"sludge",
"slug",
"slugabed",
"slugfest",
"sluggard",
"slugger",
"sluggishness",
"sluice",
"sluicegate",
"sluiceway",
"slum",
"slumber",
"slumberer",
"slumgullion",
"slump",
"slur",
"slurry",
"slush",
"slut",
"sluttishness",
"slyboots",
"slyness",
"smack",
"smacker",
"smacking",
"small",
"smalley",
"smallholder",
"smallholding",
"smallmouth",
"smallness",
"smallpox",
"smaltite",
"smarm",
"smarminess",
"smart",
"smarta",
"smarting",
"smartness",
"smash",
"smasher",
"smashing",
"smattering",
"smear",
"smegma",
"smell",
"smelling",
"smelt",
"smelter",
"smeltery",
"smetana",
"smew",
"smidge",
"smidgen",
"smidgeon",
"smidgin",
"smilacaceae",
"smilax",
"smile",
"smiledon",
"smiler",
"smiley",
"smiling",
"smilo",
"smirch",
"smirk",
"smirker",
"smitane",
"smith",
"smithereens",
"smithy",
"smock",
"smocking",
"smog",
"smogginess",
"smoke",
"smokehouse",
"smoker",
"smokescreen",
"smokestack",
"smoking",
"smolder",
"smolensk",
"smollett",
"smooch",
"smooching",
"smooth",
"smoothbark",
"smoothbore",
"smoother",
"smoothhound",
"smoothie",
"smoothness",
"smoothy",
"smorgasbord",
"smother",
"smotherer",
"smoulder",
"smsgt",
"smudge",
"smuggler",
"smuggling",
"smugness",
"smut",
"smuts",
"smuttiness",
"smyrna",
"smyrnium",
"snack",
"snacker",
"snaffle",
"snafu",
"snag",
"snail",
"snailfish",
"snailflower",
"snake",
"snakeberry",
"snakebird",
"snakebite",
"snakeblenny",
"snakefish",
"snakefly",
"snakehead",
"snakeroot",
"snakeweed",
"snakewood",
"snap",
"snapdragon",
"snapline",
"snapper",
"snappishness",
"snapshot",
"snare",
"snarer",
"snarl",
"snatch",
"snatcher",
"snead",
"sneak",
"sneaker",
"sneakiness",
"sneer",
"sneerer",
"sneeze",
"sneezer",
"sneezeweed",
"sneezewort",
"sneezing",
"snellen",
"snick",
"snicker",
"snickersnee",
"sniff",
"sniffer",
"sniffle",
"sniffler",
"snifter",
"snigger",
"snip",
"snipe",
"snipefish",
"sniper",
"snippet",
"snipping",
"snips",
"snit",
"snitch",
"snitcher",
"snivel",
"sniveler",
"sniveling",
"sniveller",
"snob",
"snobbery",
"snobbishness",
"snobbism",
"snoek",
"snogging",
"snood",
"snook",
"snooker",
"snoop",
"snooper",
"snoopiness",
"snoopy",
"snoot",
"snootiness",
"snooze",
"snore",
"snorer",
"snoring",
"snorkel",
"snorkeling",
"snort",
"snorter",
"snorting",
"snot",
"snout",
"snow",
"snowball",
"snowbank",
"snowbell",
"snowberry",
"snowbird",
"snowblindness",
"snowboard",
"snowboarder",
"snowboarding",
"snowcap",
"snowdrift",
"snowdrop",
"snowfall",
"snowfield",
"snowflake",
"snowman",
"snowmobile",
"snowplough",
"snowplow",
"snowshoe",
"snowstorm",
"snowsuit",
"snub",
"snuff",
"snuffbox",
"snuffer",
"snuffers",
"snuffle",
"snuffler",
"snug",
"snuggery",
"snuggle",
"snuggling",
"snugness",
"soak",
"soakage",
"soaker",
"soaking",
"soap",
"soapberry",
"soapbox",
"soapfish",
"soapiness",
"soaprock",
"soapstone",
"soapsuds",
"soapweed",
"soapwort",
"soar",
"soaring",
"soave",
"sobbing",
"soberness",
"sobersides",
"sobralia",
"sobriety",
"sobriquet",
"socage",
"soccer",
"sociability",
"sociable",
"sociableness",
"social",
"socialisation",
"socialiser",
"socialising",
"socialism",
"socialist",
"socialite",
"sociality",
"socialization",
"socializer",
"socializing",
"society",
"socinian",
"socinus",
"sociobiologist",
"sociobiology",
"sociolinguist",
"sociologist",
"sociology",
"sociometry",
"sociopath",
"sock",
"socket",
"sockeye",
"socle",
"socrates",
"soda",
"sodalist",
"sodalite",
"sodality",
"sodbuster",
"soddy",
"sodium",
"sodoku",
"sodom",
"sodomist",
"sodomite",
"sodomy",
"sofa",
"soffit",
"sofia",
"softback",
"softball",
"softener",
"softening",
"softheartedness",
"softie",
"softness",
"software",
"softwood",
"softy",
"sogginess",
"soho",
"soil",
"soiling",
"soilure",
"soiree",
"soissons",
"soja",
"sojourn",
"sojourner",
"sokoro",
"solace",
"solacement",
"solan",
"solanaceae",
"solandra",
"solanopteris",
"solanum",
"solarisation",
"solarium",
"solarization",
"solder",
"solderer",
"soldering",
"soldier",
"soldierfish",
"soldiering",
"soldiership",
"soldiery",
"sole",
"solea",
"solecism",
"soledad",
"soleidae",
"soleirolia",
"solemness",
"solemnisation",
"solemnity",
"solemnization",
"solenichthyes",
"solenidae",
"solenogaster",
"solenogastres",
"solenoid",
"solenopsis",
"solenostemon",
"solent",
"soleus",
"solfa",
"solfege",
"solfeggio",
"solferino",
"solicitation",
"solicitor",
"solicitorship",
"solicitousness",
"solicitude",
"solid",
"solidago",
"solidarity",
"solidification",
"solidifying",
"solidity",
"solidness",
"solidus",
"soliloquy",
"solingen",
"solipsism",
"solitaire",
"solitariness",
"solitary",
"soliton",
"solitude",
"solitudinarian",
"solleret",
"solmisation",
"solmization",
"solo",
"soloist",
"solomon",
"solomons",
"solon",
"solresol",
"solstice",
"solubility",
"solubleness",
"solute",
"solution",
"solvability",
"solvate",
"solvation",
"solvay",
"solvency",
"solvent",
"solver",
"solving",
"solzhenitsyn",
"soma",
"somaesthesia",
"somaesthesis",
"somali",
"somalia",
"somalian",
"soman",
"somataesthesis",
"somateria",
"somatesthesia",
"somatosense",
"somatotrophin",
"somatotropin",
"somatotype",
"somberness",
"sombreness",
"sombrero",
"somebody",
"someone",
"somersault",
"somersaulting",
"somerset",
"somesthesia",
"somesthesis",
"somewhere",
"somite",
"somme",
"sommelier",
"somnambulation",
"somnambulism",
"somnambulist",
"somniloquism",
"somniloquist",
"somniloquy",
"somnolence",
"somrai",
"sonant",
"sonar",
"sonata",
"sonatina",
"sonchus",
"sondheim",
"sone",
"song",
"songbird",
"songbook",
"songfulness",
"songhai",
"songster",
"songstress",
"songwriter",
"sonnet",
"sonneteer",
"sonny",
"sonogram",
"sonograph",
"sonography",
"sonometer",
"sonora",
"sonority",
"sonorousness",
"sontag",
"soochong",
"sooner",
"soot",
"sooth",
"soothsayer",
"soothsaying",
"sootiness",
"soph",
"sophism",
"sophist",
"sophisticate",
"sophistication",
"sophistry",
"sophocles",
"sophomore",
"sophonias",
"sophora",
"sopor",
"soporific",
"soprano",
"sops",
"sorb",
"sorbate",
"sorbent",
"sorbet",
"sorbian",
"sorbonne",
"sorbus",
"sorcerer",
"sorceress",
"sorcery",
"sordidness",
"sordino",
"sore",
"sorehead",
"soreness",
"sorensen",
"sorex",
"sorgho",
"sorghum",
"sorgo",
"soricidae",
"sorority",
"sorption",
"sorrel",
"sorriness",
"sorrow",
"sorrower",
"sorrowfulness",
"sort",
"sorter",
"sortie",
"sorting",
"sortition",
"sorus",
"soteriology",
"sothis",
"sotho",
"sottishness",
"souari",
"soubise",
"soubrette",
"soubriquet",
"souchong",
"soudan",
"souffle",
"soufflot",
"souk",
"soul",
"soulfulness",
"sound",
"soundboard",
"soundbox",
"sounder",
"sounding",
"soundlessness",
"soundman",
"soundness",
"soundtrack",
"soup",
"soupcon",
"soupfin",
"soupiness",
"soupspoon",
"sour",
"sourball",
"source",
"sourdine",
"sourdough",
"souring",
"sourness",
"sourpuss",
"soursop",
"sourwood",
"sousa",
"sousaphone",
"souse",
"sousing",
"souslik",
"sousse",
"soutache",
"soutane",
"south",
"southeast",
"southeaster",
"southeastward",
"souther",
"southerly",
"southerner",
"southernism",
"southernness",
"southernwood",
"southey",
"southland",
"southpaw",
"southward",
"southwest",
"southwester",
"southwestern",
"southwestward",
"soutine",
"souvenir",
"souvlaki",
"souvlakia",
"sovereign",
"sovereignty",
"soviet",
"sovietism",
"soviets",
"sowbane",
"sowbelly",
"sowbread",
"sower",
"soweto",
"soya",
"soybean",
"soymilk",
"space",
"spacecraft",
"spacefaring",
"spaceflight",
"spaceman",
"spaceship",
"spacesuit",
"spacewalker",
"spacing",
"spaciousness",
"spackle",
"spade",
"spadefish",
"spadefoot",
"spadeful",
"spadework",
"spadix",
"spaghetti",
"spaghettini",
"spain",
"spalacidae",
"spalax",
"spall",
"spallanzani",
"spallation",
"spam",
"spammer",
"span",
"spandau",
"spandex",
"spandrel",
"spandril",
"spangle",
"spaniard",
"spaniel",
"spanish",
"spank",
"spanker",
"spanking",
"spanner",
"spar",
"sparaxis",
"spare",
"spareness",
"sparer",
"sparerib",
"spareribs",
"sparganiaceae",
"sparganium",
"sparge",
"sparid",
"sparidae",
"spark",
"sparker",
"sparkle",
"sparkleberry",
"sparkler",
"sparkling",
"sparling",
"sparmannia",
"sparring",
"sparrow",
"sparseness",
"sparsity",
"sparta",
"spartan",
"spartina",
"spartium",
"spasm",
"spasmolysis",
"spasmolytic",
"spassky",
"spastic",
"spasticity",
"spat",
"spatangoida",
"spatchcock",
"spate",
"spathe",
"spathiphyllum",
"spatiality",
"spatter",
"spatterdock",
"spattering",
"spatula",
"spavin",
"spawl",
"spawn",
"spawner",
"spaying",
"speakeasy",
"speaker",
"speakerphone",
"speakership",
"speaking",
"spear",
"spearfish",
"spearhead",
"spearmint",
"spearpoint",
"spec",
"special",
"specialisation",
"specialiser",
"specialism",
"specialist",
"speciality",
"specialization",
"specializer",
"specialness",
"specialty",
"speciation",
"specie",
"species",
"specific",
"specification",
"specificity",
"specifier",
"specimen",
"speciousness",
"speck",
"speckle",
"specs",
"spectacle",
"spectacles",
"spectacular",
"spectator",
"specter",
"spectinomycin",
"spectre",
"spectrogram",
"spectrograph",
"spectrometer",
"spectrometry",
"spectroscope",
"spectroscopy",
"spectrum",
"speculation",
"speculativeness",
"speculator",
"speculum",
"speech",
"speechifier",
"speechlessness",
"speechmaker",
"speechmaking",
"speechwriter",
"speed",
"speedboat",
"speeder",
"speediness",
"speeding",
"speedometer",
"speedskater",
"speedup",
"speedway",
"speedwell",
"speer",
"speke",
"spelaeologist",
"spelaeology",
"speleologist",
"speleology",
"spell",
"spellbinder",
"spelldown",
"speller",
"spelling",
"spelt",
"spelter",
"spelunker",
"spencer",
"spender",
"spending",
"spendthrift",
"spengler",
"spenser",
"spergula",
"spergularia",
"sperm",
"spermaceti",
"spermatid",
"spermatocele",
"spermatocide",
"spermatocyte",
"spermatogenesis",
"spermatophyta",
"spermatophyte",
"spermatozoan",
"spermatozoid",
"spermatozoon",
"spermicide",
"spermophile",
"spermophilus",
"sperry",
"spewer",
"sphacele",
"sphacelotheca",
"sphacelus",
"sphaeralcea",
"sphaeriaceae",
"sphaeriales",
"sphaerobolaceae",
"sphaerocarpales",
"sphaerocarpos",
"sphaerocarpus",
"sphagnales",
"sphagnum",
"sphalerite",
"sphecidae",
"sphecius",
"sphecoid",
"sphecoidea",
"sphecotheres",
"sphenion",
"spheniscidae",
"sphenisciformes",
"spheniscus",
"sphenodon",
"sphenoid",
"sphenopsida",
"sphere",
"sphericalness",
"sphericity",
"spherocyte",
"spheroid",
"spherometer",
"spherule",
"sphincter",
"sphingid",
"sphingidae",
"sphinx",
"sphyraena",
"sphyraenidae",
"sphyrapicus",
"sphyrna",
"sphyrnidae",
"spic",
"spica",
"spiccato",
"spice",
"spiceberry",
"spicebush",
"spicemill",
"spicery",
"spiciness",
"spick",
"spicule",
"spiculum",
"spider",
"spiderflower",
"spiderwort",
"spiegel",
"spiegeleisen",
"spiel",
"spielberg",
"spiff",
"spigot",
"spik",
"spike",
"spikelet",
"spikemoss",
"spikenard",
"spile",
"spill",
"spillage",
"spillane",
"spiller",
"spillikin",
"spillikins",
"spillover",
"spillway",
"spilogale",
"spin",
"spinach",
"spinacia",
"spinal",
"spindle",
"spindleberry",
"spindlelegs",
"spindleshanks",
"spindrift",
"spine",
"spinel",
"spinelessness",
"spinet",
"spininess",
"spinmeister",
"spinnability",
"spinnaker",
"spinnbarkeit",
"spinner",
"spinney",
"spinning",
"spinoza",
"spinster",
"spinsterhood",
"spinus",
"spiracle",
"spiraea",
"spiral",
"spirant",
"spiranthes",
"spire",
"spirea",
"spirilla",
"spirillaceae",
"spirillum",
"spirit",
"spiritedness",
"spiritism",
"spiritlessness",
"spirits",
"spiritual",
"spiritualism",
"spiritualist",
"spirituality",
"spiritualty",
"spirochaeta",
"spirochaetaceae",
"spirochaetales",
"spirochaete",
"spirochete",
"spirodela",
"spirogram",
"spirograph",
"spirogyra",
"spirometer",
"spirometry",
"spironolactone",
"spirt",
"spirula",
"spirulidae",
"spit",
"spitball",
"spite",
"spitefulness",
"spitfire",
"spitsbergen",
"spitter",
"spitting",
"spittle",
"spittlebug",
"spittoon",
"spitz",
"spitzbergen",
"spiv",
"spizella",
"splash",
"splashboard",
"splashdown",
"splasher",
"splashiness",
"splashing",
"splat",
"splatter",
"splattering",
"splay",
"splayfoot",
"spleen",
"spleenwort",
"splendor",
"splendour",
"splenectomy",
"splenitis",
"splenius",
"splenomegaly",
"splice",
"splicer",
"splicing",
"spliff",
"spline",
"splint",
"splinter",
"splintering",
"splinters",
"split",
"splitsaw",
"splitsville",
"splitter",
"splitworm",
"splodge",
"splotch",
"splurge",
"splutter",
"spock",
"spode",
"spodoptera",
"spodumene",
"spoil",
"spoilable",
"spoilage",
"spoilation",
"spoiler",
"spoiling",
"spoilsport",
"spokane",
"spoke",
"spokeshave",
"spokesman",
"spokesperson",
"spokeswoman",
"spoliation",
"spondee",
"spondias",
"spondylitis",
"sponge",
"spongefly",
"sponger",
"spongillafly",
"sponginess",
"spongioblast",
"spongioblastoma",
"sponsor",
"sponsorship",
"spontaneity",
"spontaneousness",
"spoof",
"spook",
"spool",
"spoon",
"spoonbill",
"spoondrift",
"spoonerism",
"spoonfeeding",
"spoonflower",
"spoonful",
"spoor",
"sporangiophore",
"sporangium",
"sporanox",
"spore",
"spork",
"sporobolus",
"sporocarp",
"sporophore",
"sporophyl",
"sporophyll",
"sporophyte",
"sporotrichosis",
"sporozoa",
"sporozoan",
"sporozoite",
"sporran",
"sport",
"sportfishing",
"sportiveness",
"sportscast",
"sportscaster",
"sportsman",
"sportsmanship",
"sportswear",
"sportswoman",
"sportswriter",
"sporulation",
"spot",
"spotlessness",
"spotlight",
"spots",
"spotsylvania",
"spotter",
"spotting",
"spouse",
"spout",
"spouter",
"sprachgefuhl",
"sprag",
"spraguea",
"sprain",
"sprat",
"sprawl",
"sprawler",
"sprawling",
"spray",
"sprayer",
"spraying",
"spread",
"spreader",
"spreadhead",
"spreading",
"spreadsheet",
"sprechgesang",
"sprechstimme",
"spree",
"sprig",
"sprigger",
"sprightliness",
"sprigtail",
"spring",
"springboard",
"springbok",
"springbuck",
"springer",
"springfield",
"springiness",
"springtail",
"springtide",
"springtime",
"sprinkle",
"sprinkler",
"sprinkles",
"sprinkling",
"sprint",
"sprinter",
"sprit",
"sprite",
"sprites",
"spritsail",
"spritz",
"spritzer",
"sprocket",
"sprog",
"sprout",
"sprouting",
"spruce",
"spruceness",
"sprue",
"spud",
"spume",
"spunk",
"spur",
"spurge",
"spuriousness",
"spurner",
"spurring",
"spurt",
"sputnik",
"sputter",
"sputtering",
"sputum",
"spyeria",
"spyglass",
"spyhole",
"spying",
"spymaster",
"spyware",
"squab",
"squabble",
"squabbler",
"squad",
"squadron",
"squalidae",
"squalidness",
"squall",
"squalor",
"squalus",
"squama",
"squamata",
"squamule",
"squanderer",
"squandering",
"squandermania",
"square",
"squareness",
"squaretail",
"squark",
"squash",
"squat",
"squatina",
"squatinidae",
"squatness",
"squatter",
"squattiness",
"squatting",
"squaw",
"squawbush",
"squawk",
"squawker",
"squawroot",
"squeak",
"squeaker",
"squeal",
"squealer",
"squeamishness",
"squeegee",
"squeezability",
"squeeze",
"squeezer",
"squeezing",
"squelch",
"squelcher",
"squib",
"squid",
"squiggle",
"squill",
"squilla",
"squillidae",
"squinch",
"squint",
"squinter",
"squire",
"squirearchy",
"squirm",
"squirmer",
"squirrel",
"squirrelfish",
"squirt",
"squirter",
"squish",
"sravana",
"srbija",
"sspe",
"ssri",
"stab",
"stabber",
"stabile",
"stabilisation",
"stabiliser",
"stability",
"stabilization",
"stabilizer",
"stable",
"stableboy",
"stableman",
"stablemate",
"stableness",
"stabling",
"stabroek",
"stachyose",
"stachys",
"stack",
"stacker",
"stacks",
"stacte",
"staddle",
"stadium",
"stael",
"staff",
"staffa",
"staffer",
"stag",
"stage",
"stagecoach",
"stagecraft",
"stagehand",
"stager",
"stagflation",
"stagger",
"staggerbush",
"staggerer",
"staggers",
"staghead",
"staghound",
"staginess",
"staging",
"stagira",
"stagirus",
"stagnancy",
"stagnation",
"staidness",
"stain",
"stainability",
"stainer",
"staining",
"stainless",
"stair",
"staircase",
"stairhead",
"stairs",
"stairway",
"stairwell",
"stake",
"stakeholder",
"stakeout",
"stakes",
"stalactite",
"stalagmite",
"stalemate",
"staleness",
"stalin",
"stalinabad",
"stalingrad",
"stalinisation",
"stalinism",
"stalinist",
"stalinization",
"stalino",
"stalk",
"stalker",
"stalking",
"stall",
"stalling",
"stallion",
"stalls",
"stalwart",
"stalwartness",
"stamboul",
"stambul",
"stamen",
"stamina",
"stammel",
"stammer",
"stammerer",
"stamp",
"stampede",
"stamper",
"stance",
"stanchion",
"stand",
"standard",
"standardisation",
"standardiser",
"standardization",
"standardizer",
"standby",
"standdown",
"standee",
"stander",
"standing",
"standish",
"standoff",
"standoffishness",
"standpipe",
"standpoint",
"standstill",
"stanford",
"stanhope",
"stanhopea",
"stanislavsky",
"stanley",
"stanleya",
"stannite",
"stanton",
"stanza",
"stapedectomy",
"stapelia",
"stapes",
"staph",
"staphylaceae",
"staphylea",
"staphylinidae",
"staphylococci",
"staphylococcus",
"staple",
"staplegun",
"stapler",
"star",
"starboard",
"starch",
"starches",
"stardom",
"stardust",
"stare",
"starer",
"starets",
"starfish",
"starflower",
"stargazer",
"stargazing",
"starkey",
"starkness",
"starlet",
"starlight",
"starling",
"starr",
"starship",
"start",
"starter",
"starting",
"startle",
"startup",
"starvation",
"starveling",
"starving",
"starwort",
"stash",
"stasis",
"state",
"statecraft",
"statehouse",
"stateliness",
"statement",
"stater",
"stateroom",
"statesman",
"statesmanship",
"stateswoman",
"static",
"statice",
"statics",
"statin",
"station",
"stationariness",
"stationer",
"stationery",
"stationmaster",
"stations",
"statistic",
"statistician",
"statistics",
"stator",
"statuary",
"statue",
"statuette",
"stature",
"status",
"statute",
"staunchness",
"staurikosaur",
"staurikosaurus",
"stavanger",
"stave",
"stay",
"stayer",
"stayman",
"stays",
"staysail",
"stead",
"steadfastness",
"steadiness",
"steady",
"steak",
"steakhouse",
"steal",
"stealer",
"stealing",
"stealth",
"stealthiness",
"steam",
"steamboat",
"steamer",
"steamfitter",
"steaminess",
"steamroller",
"steamship",
"stearin",
"steatite",
"steatocystoma",
"steatopygia",
"steatornis",
"steatornithidae",
"steatorrhea",
"steed",
"steel",
"steele",
"steelmaker",
"steelman",
"steelworker",
"steelworks",
"steelyard",
"steen",
"steenbok",
"steep",
"steeper",
"steeple",
"steeplechase",
"steeplechaser",
"steeplejack",
"steepness",
"steer",
"steerage",
"steerageway",
"steerer",
"steering",
"steersman",
"steffens",
"steganography",
"steganopus",
"stegocephalia",
"stegosaur",
"stegosaurus",
"steichen",
"stein",
"steinbeck",
"steinberg",
"steinbok",
"steinem",
"steiner",
"steinman",
"steinmetz",
"steinway",
"stela",
"stele",
"stelis",
"stella",
"stellaria",
"steller",
"stellite",
"stem",
"stemma",
"stemmatics",
"stemmatology",
"stemmer",
"stench",
"stencil",
"stendhal",
"stengel",
"stenocarpus",
"stenochlaena",
"stenograph",
"stenographer",
"stenography",
"stenopelmatidae",
"stenopelmatus",
"stenopterygius",
"stenosis",
"stenotaphrum",
"stenotomus",
"stenotus",
"stent",
"stentor",
"step",
"stepbrother",
"stepchild",
"stepdaughter",
"stepfather",
"stephanion",
"stephanomeria",
"stephanotis",
"stephead",
"stephen",
"stephenson",
"stepladder",
"stepmother",
"stepparent",
"steppe",
"stepper",
"steps",
"stepsister",
"stepson",
"steradian",
"stercobilinogen",
"stercolith",
"stercorariidae",
"stercorarius",
"sterculia",
"sterculiaceae",
"stereo",
"stereophony",
"stereoscope",
"stereoscopy",
"stereospondyli",
"stereotype",
"sterileness",
"sterilisation",
"steriliser",
"sterility",
"sterilization",
"sterilizer",
"sterling",
"stern",
"sterna",
"sterne",
"sterninae",
"sternness",
"sternotherus",
"sternpost",
"sternum",
"sternutation",
"sternutator",
"sternutatory",
"sternwheeler",
"steroid",
"sterol",
"sterope",
"stertor",
"stethoscope",
"stetson",
"steuben",
"stevedore",
"stevens",
"stevenson",
"stevia",
"stew",
"steward",
"stewardess",
"stewardship",
"stewart",
"stewing",
"stewpan",
"sthene",
"stheno",
"stibnite",
"stichaeidae",
"sticherus",
"stick",
"stickball",
"sticker",
"stickiness",
"stickleback",
"stickler",
"stickpin",
"sticktight",
"stickup",
"stickweed",
"stictomys",
"stictopelia",
"stieglitz",
"stiff",
"stiffener",
"stiffening",
"stiffness",
"stifle",
"stifler",
"stifling",
"stigma",
"stigmata",
"stigmatic",
"stigmatisation",
"stigmatism",
"stigmatist",
"stigmatization",
"stilbesterol",
"stilbestrol",
"stilboestrol",
"stile",
"stiletto",
"still",
"stillbirth",
"stillness",
"stillroom",
"stilt",
"stiltbird",
"stilton",
"stilwell",
"stimulant",
"stimulation",
"stimulus",
"sting",
"stinger",
"stinginess",
"stinging",
"stingray",
"stink",
"stinkbird",
"stinker",
"stinkhorn",
"stinkiness",
"stinkpot",
"stinkweed",
"stint",
"stinter",
"stipe",
"stipend",
"stipendiary",
"stippler",
"stipulation",
"stipule",
"stir",
"stirk",
"stirrer",
"stirring",
"stirrup",
"stitch",
"stitcher",
"stitchery",
"stitching",
"stitchwort",
"stizidae",
"stizolobium",
"stizostedion",
"stoat",
"stob",
"stochasticity",
"stock",
"stockade",
"stockbroker",
"stockcar",
"stocker",
"stockfish",
"stockholder",
"stockholding",
"stockholdings",
"stockholm",
"stockhorn",
"stockinet",
"stockinette",
"stocking",
"stockist",
"stockjobber",
"stockman",
"stockpile",
"stockpiling",
"stockpot",
"stockroom",
"stocks",
"stocktake",
"stocktaker",
"stocktaking",
"stockton",
"stockyard",
"stodge",
"stodginess",
"stoep",
"stogie",
"stogy",
"stoic",
"stoichiometry",
"stoicism",
"stokehold",
"stokehole",
"stoker",
"stokesia",
"stokowski",
"stole",
"stolidity",
"stolidness",
"stolon",
"stoma",
"stomach",
"stomachache",
"stomacher",
"stomate",
"stomatitis",
"stomatopod",
"stomatopoda",
"stomp",
"stomper",
"stone",
"stonechat",
"stonecress",
"stonecrop",
"stonecutter",
"stoneface",
"stonefish",
"stonefly",
"stonehenge",
"stonemason",
"stoner",
"stoneroot",
"stonewaller",
"stonewalling",
"stoneware",
"stonework",
"stonewort",
"stoning",
"stooge",
"stool",
"stoolie",
"stoolpigeon",
"stoop",
"stooper",
"stop",
"stopcock",
"stopes",
"stopgap",
"stoplight",
"stopover",
"stoppage",
"stoppard",
"stopper",
"stopping",
"stopple",
"stops",
"stopwatch",
"storage",
"storax",
"store",
"storefront",
"storehouse",
"storekeeper",
"storeria",
"storeroom",
"storey",
"stork",
"storksbill",
"storm",
"storminess",
"story",
"storybook",
"storyline",
"storyteller",
"stotinka",
"stoup",
"stout",
"stoutness",
"stove",
"stovepipe",
"stovepiping",
"stover",
"stowage",
"stowaway",
"stowe",
"stowing",
"strabismus",
"strabotomy",
"strachey",
"strad",
"stradavarius",
"straddle",
"stradivari",
"stradivarius",
"strafe",
"strafer",
"straggle",
"straggler",
"straight",
"straightaway",
"straightedge",
"straightener",
"straightjacket",
"straightness",
"strain",
"strainer",
"straining",
"strait",
"straitjacket",
"straits",
"strake",
"strand",
"strangeness",
"stranger",
"stranglehold",
"strangler",
"strangles",
"strangling",
"strangulation",
"strap",
"strapado",
"straphanger",
"strapless",
"strappado",
"strapper",
"strasberg",
"strasbourg",
"strassburg",
"stratagem",
"strategian",
"strategics",
"strategist",
"strategy",
"stratification",
"stratigraphy",
"stratocracy",
"stratosphere",
"stratum",
"stratus",
"strauss",
"stravinsky",
"straw",
"strawberry",
"strawboard",
"strawflower",
"strawman",
"strawworm",
"stray",
"strayer",
"streak",
"streaker",
"stream",
"streambed",
"streamer",
"streaming",
"streamlet",
"streamliner",
"streep",
"street",
"streetcar",
"streetlight",
"streetwalker",
"streisand",
"strekelia",
"strelitzia",
"strelitziaceae",
"strength",
"strengthener",
"strengthening",
"strenuosity",
"strenuousness",
"strep",
"strepera",
"strepsiceros",
"strepsirhini",
"streptobacillus",
"streptocarpus",
"streptococci",
"streptococcus",
"streptodornase",
"streptokinase",
"streptolysin",
"streptomyces",
"streptomycin",
"streptopelia",
"streptosolen",
"streptothricin",
"stress",
"stressor",
"stretch",
"stretchability",
"stretcher",
"stretchiness",
"stretching",
"streusel",
"strewing",
"stria",
"striation",
"striatum",
"strickland",
"strickle",
"strictness",
"stricture",
"stride",
"stridence",
"stridency",
"strider",
"stridor",
"stridulation",
"strife",
"strigidae",
"strigiformes",
"strike",
"strikebreaker",
"strikebreaking",
"strikeout",
"striker",
"striking",
"strikingness",
"strindberg",
"string",
"stringency",
"stringer",
"strings",
"stringybark",
"strip",
"stripe",
"striper",
"stripes",
"striping",
"stripling",
"stripper",
"stripping",
"striptease",
"stripteaser",
"striver",
"striving",
"strix",
"strobe",
"strobile",
"strobilomyces",
"strobilus",
"stroboscope",
"stroheim",
"stroke",
"stroking",
"stroll",
"stroller",
"stroma",
"stromateid",
"stromateidae",
"strombidae",
"strombus",
"strongbox",
"stronghold",
"strongman",
"strongroom",
"strongylodon",
"strontianite",
"strontium",
"strop",
"strophanthin",
"strophanthus",
"stropharia",
"strophariaceae",
"strophe",
"structuralism",
"structure",
"strudel",
"struggle",
"struggler",
"strum",
"struma",
"strumpet",
"strut",
"struthio",
"struthiomimus",
"struthionidae",
"strychnine",
"strymon",
"stuart",
"stub",
"stubbiness",
"stubble",
"stubbornness",
"stubbs",
"stucco",
"stud",
"studbook",
"student",
"studentship",
"studhorse",
"studio",
"studiousness",
"study",
"studying",
"stuff",
"stuffer",
"stuffiness",
"stuffing",
"stultification",
"stumble",
"stumblebum",
"stumbler",
"stump",
"stumper",
"stumping",
"stumpknocker",
"stunner",
"stunt",
"stuntedness",
"stunting",
"stupa",
"stupe",
"stupefaction",
"stupid",
"stupidity",
"stupor",
"sturdiness",
"sturgeon",
"sturmabteilung",
"sturnella",
"sturnidae",
"sturnus",
"stutter",
"stutterer",
"stuttgart",
"stuyvesant",
"stye",
"style",
"stylemark",
"styler",
"stylet",
"stylisation",
"stylishness",
"stylist",
"stylite",
"stylization",
"stylomecon",
"stylophorum",
"stylopodium",
"stylostixis",
"stylus",
"stymie",
"stymy",
"styphelia",
"stypsis",
"styptic",
"styracaceae",
"styracosaur",
"styracosaurus",
"styrax",
"styrene",
"styrofoam",
"styron",
"styx",
"suasion",
"suaveness",
"suavity",
"subaltern",
"subbase",
"subbing",
"subclass",
"subcommittee",
"subcompact",
"subconscious",
"subcontinent",
"subcontract",
"subcontractor",
"subculture",
"subdeacon",
"subdirectory",
"subdivider",
"subdivision",
"subdominant",
"subduction",
"subduedness",
"subduer",
"subeditor",
"subfamily",
"subfigure",
"subgenus",
"subgroup",
"subhead",
"subheading",
"subject",
"subjection",
"subjectiveness",
"subjectivism",
"subjectivist",
"subjectivity",
"subjoining",
"subjugation",
"subjugator",
"subjunction",
"subjunctive",
"subkingdom",
"sublease",
"sublet",
"sublieutenant",
"sublimate",
"sublimation",
"sublimaze",
"sublimity",
"subluxation",
"submarine",
"submariner",
"submaxilla",
"submediant",
"submenu",
"submergence",
"submerging",
"submersible",
"submersion",
"submission",
"submissiveness",
"submitter",
"submucosa",
"subnormal",
"subnormality",
"suborder",
"subordinate",
"subordinateness",
"subordination",
"subornation",
"suborner",
"subpart",
"subphylum",
"subpoena",
"subpopulation",
"subprogram",
"subrogation",
"subroutine",
"subscriber",
"subscript",
"subscription",
"subsection",
"subsequence",
"subsequentness",
"subservience",
"subservientness",
"subset",
"subshrub",
"subsidence",
"subsidiarity",
"subsidiary",
"subsiding",
"subsidisation",
"subsidiser",
"subsidization",
"subsidizer",
"subsidy",
"subsistence",
"subsister",
"subsoil",
"subspace",
"subspecies",
"substance",
"substantiality",
"substantialness",
"substantiation",
"substantive",
"substation",
"substitute",
"substituting",
"substitution",
"substrate",
"substratum",
"substring",
"substructure",
"subsumption",
"subsystem",
"subterfuge",
"subthalamus",
"subtilin",
"subtitle",
"subtlety",
"subtonic",
"subtopia",
"subtotal",
"subtracter",
"subtraction",
"subtrahend",
"subtreasury",
"subtropics",
"subularia",
"subunit",
"suburb",
"suburbanite",
"suburbia",
"subvention",
"subversion",
"subversive",
"subversiveness",
"subverter",
"subvocaliser",
"subvocalizer",
"subway",
"subwoofer",
"succade",
"succedaneum",
"succeeder",
"success",
"successfulness",
"succession",
"successiveness",
"successor",
"succinctness",
"succinylcholine",
"succor",
"succorer",
"succory",
"succos",
"succotash",
"succoth",
"succour",
"succourer",
"succuba",
"succubus",
"succulence",
"succulency",
"succulent",
"succus",
"succussion",
"suck",
"sucker",
"suckerfish",
"sucking",
"suckling",
"sucralfate",
"sucrase",
"sucre",
"sucrose",
"suction",
"sudafed",
"sudan",
"sudanese",
"sudation",
"sudatorium",
"sudatory",
"sudbury",
"suddenness",
"sudoku",
"sudor",
"sudorific",
"sudra",
"suds",
"suede",
"suer",
"suet",
"suez",
"sufferance",
"sufferer",
"suffering",
"sufficiency",
"suffix",
"suffixation",
"suffocation",
"suffragan",
"suffrage",
"suffragette",
"suffragism",
"suffragist",
"suffrutex",
"suffusion",
"sufi",
"sufism",
"sugar",
"sugarberry",
"sugarcane",
"sugariness",
"sugarloaf",
"sugarplum",
"suggester",
"suggestibility",
"suggestion",
"sugi",
"suharto",
"suicide",
"suidae",
"suillus",
"suisse",
"suit",
"suitability",
"suitableness",
"suitcase",
"suite",
"suiting",
"suitor",
"sukarno",
"sukiyaki",
"sukkoth",
"suksdorfia",
"sukur",
"sula",
"sulamyd",
"sulawesi",
"sulcus",
"sulfa",
"sulfacetamide",
"sulfadiazine",
"sulfamethazine",
"sulfamezathine",
"sulfanilamide",
"sulfapyridine",
"sulfate",
"sulfide",
"sulfisoxazole",
"sulfonamide",
"sulfonate",
"sulfonylurea",
"sulfur",
"sulidae",
"sulindac",
"sulk",
"sulkiness",
"sulky",
"sulla",
"sullenness",
"sullivan",
"sully",
"sulpha",
"sulphate",
"sulphide",
"sulphur",
"sultan",
"sultana",
"sultanate",
"sultriness",
"sumac",
"sumach",
"sumatra",
"sumatran",
"sumer",
"sumerian",
"sumerology",
"summarisation",
"summarization",
"summary",
"summation",
"summer",
"summercater",
"summercaters",
"summerhouse",
"summersault",
"summerset",
"summertime",
"summit",
"summoning",
"summons",
"sumner",
"sumo",
"sump",
"sumpsimus",
"sumpter",
"sumptuosity",
"sumptuousness",
"sunbather",
"sunbeam",
"sunbelt",
"sunberry",
"sunblind",
"sunblock",
"sunbonnet",
"sunburn",
"sunburst",
"sunchoke",
"sundacarpus",
"sundae",
"sundanese",
"sunday",
"sunderland",
"sundew",
"sundial",
"sundog",
"sundown",
"sundowner",
"sundress",
"sundries",
"sundrops",
"sunfish",
"sunflower",
"sung",
"sunglass",
"sunglasses",
"sunhat",
"sunlamp",
"sunlight",
"sunna",
"sunnah",
"sunni",
"sunniness",
"sunnite",
"sunporch",
"sunray",
"sunrise",
"sunroof",
"sunroom",
"sunrose",
"sunscreen",
"sunset",
"sunshade",
"sunshine",
"sunspot",
"sunstone",
"sunstroke",
"sunsuit",
"suntan",
"suntrap",
"sunup",
"suomi",
"super",
"superabundance",
"superannuation",
"superbia",
"superbug",
"supercargo",
"supercharger",
"supercilium",
"superclass",
"supercomputer",
"superego",
"supererogation",
"superfamily",
"superfecta",
"superfetation",
"superficiality",
"superficies",
"superfluity",
"superfund",
"supergiant",
"supergrass",
"superhet",
"superhighway",
"superinfection",
"superintendence",
"superintendent",
"superior",
"superiority",
"superlative",
"superload",
"superman",
"supermarket",
"supermarketeer",
"supermarketer",
"supermex",
"supermodel",
"supermolecule",
"supermom",
"supernatant",
"supernatural",
"supernaturalism",
"supernova",
"supernumerary",
"superorder",
"superordinate",
"superordination",
"superoxide",
"superpatriotism",
"superphylum",
"superposition",
"superpower",
"superscript",
"superscription",
"supersedure",
"supersession",
"superslasher",
"superstar",
"superstition",
"superstrate",
"superstratum",
"superstring",
"superstructure",
"supersymmetry",
"supertanker",
"supertax",
"supertitle",
"supertonic",
"supertwister",
"supervention",
"supervising",
"supervision",
"supervisor",
"supination",
"supinator",
"supper",
"suppertime",
"supping",
"supplanter",
"supplanting",
"supplejack",
"supplement",
"supplementation",
"suppleness",
"suppliant",
"supplicant",
"supplication",
"supplier",
"supply",
"supplying",
"support",
"supporter",
"supporting",
"supposal",
"supposition",
"suppository",
"suppressant",
"suppresser",
"suppression",
"suppressor",
"suppuration",
"suprainfection",
"supremacism",
"supremacist",
"supremacy",
"suprematism",
"suprematist",
"supremo",
"sura",
"surbase",
"surcease",
"surcharge",
"surcoat",
"surd",
"sureness",
"surety",
"surf",
"surface",
"surfacing",
"surfactant",
"surfbird",
"surfboard",
"surfboarder",
"surfboarding",
"surfboat",
"surfeit",
"surfer",
"surffish",
"surfing",
"surfperch",
"surfriding",
"surge",
"surgeon",
"surgeonfish",
"surgery",
"suricata",
"suricate",
"surinam",
"suriname",
"surliness",
"surmisal",
"surmise",
"surmontil",
"surmounter",
"surmullet",
"surname",
"surnia",
"surplice",
"surplus",
"surplusage",
"surprint",
"surprisal",
"surprise",
"surpriser",
"surprisingness",
"surrealism",
"surrealist",
"surrebuttal",
"surrebutter",
"surrejoinder",
"surrender",
"surrenderer",
"surrey",
"surrogate",
"surround",
"surroundings",
"surtax",
"surtitle",
"surtout",
"surveillance",
"survey",
"surveying",
"surveyor",
"survival",
"survivalist",
"survivor",
"surya",
"susa",
"susah",
"susanna",
"susceptibility",
"susceptibleness",
"sushi",
"susian",
"susiana",
"suslik",
"suspect",
"suspender",
"suspense",
"suspension",
"suspensor",
"suspensory",
"suspicion",
"suspiciousness",
"suspiration",
"susquehanna",
"sussex",
"sustainability",
"sustainer",
"sustainment",
"sustenance",
"sustentation",
"susurration",
"susurrus",
"sutherland",
"sutler",
"sutra",
"suttee",
"sutura",
"suture",
"suturing",
"suva",
"suzerain",
"suzerainty",
"svalbard",
"svedberg",
"svengali",
"sverdrup",
"sverige",
"svizzera",
"svoboda",
"swab",
"swabbing",
"swad",
"swag",
"swage",
"swagger",
"swaggerer",
"swaggie",
"swagman",
"swahili",
"swain",
"swainsona",
"swale",
"swallow",
"swallowtail",
"swallowwort",
"swami",
"swammerdam",
"swamp",
"swamphen",
"swampland",
"swan",
"swanflower",
"swank",
"swanneck",
"swansea",
"swanson",
"swap",
"sward",
"swarm",
"swarthiness",
"swash",
"swashbuckler",
"swashbuckling",
"swastika",
"swat",
"swatch",
"swath",
"swathe",
"swathing",
"swatter",
"sway",
"swayer",
"swazi",
"swaziland",
"swbs",
"swbw",
"swearer",
"swearing",
"swearword",
"sweat",
"sweatband",
"sweatbox",
"sweater",
"sweating",
"sweatpants",
"sweats",
"sweatshirt",
"sweatshop",
"sweatsuit",
"swede",
"sweden",
"swedenborg",
"swedish",
"sweep",
"sweeper",
"sweeping",
"sweepstakes",
"sweet",
"sweetbread",
"sweetbreads",
"sweetbriar",
"sweetbrier",
"sweetener",
"sweetening",
"sweetheart",
"sweetie",
"sweetleaf",
"sweetmeat",
"sweetness",
"sweetpea",
"sweetsop",
"swell",
"swellhead",
"swelling",
"swertia",
"swerve",
"swerving",
"swietinia",
"swift",
"swiftlet",
"swiftness",
"swig",
"swill",
"swilling",
"swim",
"swimmer",
"swimmeret",
"swimming",
"swimsuit",
"swimwear",
"swinburne",
"swindle",
"swindler",
"swine",
"swineherd",
"swing",
"swinger",
"swinging",
"swingletree",
"swipe",
"swirl",
"swish",
"swiss",
"switch",
"switchblade",
"switchboard",
"switcher",
"switcheroo",
"switching",
"switchman",
"swither",
"switzerland",
"swivel",
"swivet",
"swiz",
"swizzle",
"swob",
"swoon",
"swoop",
"swoosh",
"swop",
"sword",
"swordfish",
"swordplay",
"swordsman",
"swordsmanship",
"swordtail",
"swot",
"sybarite",
"sycamore",
"syconium",
"sycophancy",
"sycophant",
"sydenham",
"sydney",
"syllabary",
"syllabication",
"syllabicity",
"syllabification",
"syllable",
"syllabub",
"syllabus",
"syllepsis",
"syllogiser",
"syllogism",
"syllogist",
"syllogizer",
"sylph",
"sylva",
"sylvan",
"sylvanite",
"sylvanus",
"sylviidae",
"sylviinae",
"sylvilagus",
"sylvine",
"sylvite",
"symbiosis",
"symbol",
"symbolatry",
"symbolisation",
"symboliser",
"symbolising",
"symbolism",
"symbolist",
"symbolization",
"symbolizer",
"symbolizing",
"symbology",
"symbololatry",
"symmetricalness",
"symmetry",
"symonds",
"symons",
"sympathectomy",
"sympathiser",
"sympathizer",
"sympathy",
"sympatry",
"symphalangus",
"symphilid",
"symphonist",
"symphony",
"symphoricarpos",
"symphyla",
"symphysion",
"symphysis",
"symphytum",
"symplocaceae",
"symplocarpus",
"symploce",
"symplocus",
"symposiarch",
"symposiast",
"symposium",
"symptom",
"synaeresis",
"synaesthesia",
"synagogue",
"synagrops",
"synanceja",
"synapse",
"synapsid",
"synapsida",
"synapsis",
"synaptomys",
"syncarp",
"syncategorem",
"syncategoreme",
"synchro",
"synchroflash",
"synchromesh",
"synchroneity",
"synchronicity",
"synchronisation",
"synchroniser",
"synchronising",
"synchronism",
"synchronization",
"synchronizer",
"synchronizing",
"synchronoscope",
"synchrony",
"synchroscope",
"synchrotron",
"synchytriaceae",
"synchytrium",
"syncopation",
"syncopator",
"syncope",
"syncretism",
"syncytium",
"syndactylism",
"syndactyly",
"syndic",
"syndicalism",
"syndicalist",
"syndicate",
"syndication",
"syndicator",
"syndrome",
"synecdoche",
"synechia",
"synentognathi",
"synercus",
"syneresis",
"synergism",
"synergist",
"synergy",
"synesthesia",
"synezesis",
"synge",
"syngnathidae",
"syngnathus",
"syngonium",
"synizesis",
"synod",
"synodontidae",
"synonym",
"synonymist",
"synonymity",
"synonymousness",
"synonymy",
"synopsis",
"synoptics",
"synovia",
"synovitis",
"synovium",
"synset",
"syntactician",
"syntagm",
"syntagma",
"syntax",
"synthesis",
"synthesiser",
"synthesist",
"synthesizer",
"synthetic",
"synthetism",
"syph",
"syphilis",
"syphilitic",
"syphon",
"syracuse",
"syria",
"syrian",
"syringa",
"syringe",
"syrinx",
"syrrhaptes",
"syrup",
"system",
"systematics",
"systematisation",
"systematiser",
"systematism",
"systematist",
"systematization",
"systematizer",
"systemiser",
"systemizer",
"systole",
"syzygium",
"syzygy",
"szechuan",
"szechwan",
"szell",
"szilard",
"taal",
"tabanidae",
"tabard",
"tabasco",
"tabbouleh",
"tabby",
"tabernacle",
"tabernacles",
"tabernaemontana",
"tabes",
"tabi",
"tabis",
"tablature",
"table",
"tableau",
"tablecloth",
"tablefork",
"tableland",
"tablemate",
"tablespoon",
"tablespoonful",
"tablet",
"tabletop",
"tableware",
"tabloid",
"taboo",
"tabooli",
"tabor",
"tabora",
"taboret",
"tabour",
"tabouret",
"tabriz",
"tabu",
"tabuk",
"tabulation",
"tabulator",
"tabun",
"tacamahac",
"tacca",
"taccaceae",
"tach",
"tacheometer",
"tachinidae",
"tachistoscope",
"tachogram",
"tachograph",
"tachometer",
"tachycardia",
"tachyglossidae",
"tachyglossus",
"tachygraphy",
"tachylite",
"tachymeter",
"tachypleus",
"taciturnity",
"tacitus",
"tack",
"tacker",
"tackiness",
"tacking",
"tackle",
"tackler",
"taco",
"tacoma",
"taconite",
"tact",
"tactfulness",
"tactic",
"tactician",
"tactics",
"tactility",
"tactlessness",
"tadalafil",
"tadarida",
"tadjik",
"tadorna",
"tadpole",
"tadzhik",
"tadzhikistan",
"taegu",
"taekwondo",
"tael",
"taenia",
"taeniidae",
"taffeta",
"taffrail",
"taffy",
"taft",
"tagalog",
"tagalong",
"tagamet",
"tagasaste",
"tageteste",
"tagger",
"tagliatelle",
"tagore",
"taguan",
"tagus",
"tahini",
"tahiti",
"tahitian",
"taichi",
"taichichuan",
"taichung",
"taif",
"tail",
"tailback",
"tailboard",
"tailcoat",
"tailfin",
"tailflower",
"tailgate",
"tailgater",
"tailing",
"taillight",
"tailor",
"tailorbird",
"tailoring",
"tailpiece",
"tailpipe",
"tailplane",
"tailrace",
"tails",
"tailspin",
"tailstock",
"tailwind",
"tailwort",
"taint",
"taipan",
"taipeh",
"taipei",
"taira",
"taiwan",
"taiwanese",
"taiyuan",
"tajik",
"tajiki",
"tajikistan",
"taka",
"takahe",
"takakkaw",
"take",
"takeaway",
"takedown",
"takelma",
"takeoff",
"takeout",
"takeover",
"taker",
"takilman",
"takin",
"taking",
"takings",
"tala",
"talapoin",
"talaria",
"talbot",
"talc",
"talcum",
"tale",
"taleban",
"talebearer",
"talent",
"talentlessness",
"taleteller",
"taliban",
"talien",
"talinum",
"talipes",
"talipot",
"talisman",
"talk",
"talkativeness",
"talker",
"talkie",
"talking",
"talks",
"tall",
"tallahassee",
"tallapoosa",
"tallboy",
"tallchief",
"talleyrand",
"tallgrass",
"tallin",
"tallinn",
"tallis",
"tallith",
"tallness",
"tallow",
"tally",
"tallyman",
"talmud",
"talon",
"talpidae",
"talus",
"talwin",
"tamal",
"tamale",
"tamandu",
"tamandua",
"tamanoir",
"tamarack",
"tamarao",
"tamarau",
"tamaricaceae",
"tamarillo",
"tamarin",
"tamarind",
"tamarindo",
"tamarindus",
"tamarisk",
"tamarix",
"tambac",
"tambala",
"tambocor",
"tambour",
"tambourine",
"tamburlaine",
"tameness",
"tamer",
"tamerlane",
"tamias",
"tamiasciurus",
"tamil",
"tamm",
"tammany",
"tammerfors",
"tammuz",
"tammy",
"tamoxifen",
"tamp",
"tampa",
"tampax",
"tamper",
"tampere",
"tampering",
"tampico",
"tampion",
"tampon",
"tamponade",
"tamponage",
"tamus",
"tanacetum",
"tanach",
"tanager",
"tanakh",
"tanbark",
"tancred",
"tandearil",
"tandem",
"tandoor",
"tandy",
"tanekaha",
"taney",
"tang",
"tanga",
"tanganyika",
"tange",
"tangelo",
"tangency",
"tangent",
"tangerine",
"tangibility",
"tangibleness",
"tangier",
"tangiers",
"tanginess",
"tangle",
"tanglebush",
"tango",
"tangor",
"tangram",
"tangshan",
"tanguy",
"tank",
"tanka",
"tankage",
"tankard",
"tanker",
"tankful",
"tannenberg",
"tanner",
"tannery",
"tannia",
"tannin",
"tanning",
"tannoy",
"tanoan",
"tansy",
"tantaliser",
"tantalite",
"tantalization",
"tantalizer",
"tantalum",
"tantalus",
"tantilla",
"tantra",
"tantrism",
"tantrist",
"tantrum",
"tanzania",
"tanzanian",
"tanzim",
"taoiseach",
"taoism",
"taoist",
"taos",
"tapa",
"tape",
"tapeline",
"tapenade",
"taper",
"tapering",
"tapestry",
"tapeworm",
"taphephobia",
"taphouse",
"taping",
"tapioca",
"tapir",
"tapiridae",
"tapirus",
"tapis",
"tapotement",
"tappa",
"tappan",
"tapper",
"tappet",
"tapping",
"taproom",
"taproot",
"taps",
"tapster",
"tara",
"tarabulus",
"taracahitian",
"taradiddle",
"tarahumara",
"taraktagenos",
"taraktogenos",
"tarantella",
"tarantelle",
"tarantino",
"tarantism",
"tarantula",
"tarawa",
"taraxacum",
"tarbell",
"tarboosh",
"tardigrada",
"tardigrade",
"tardiness",
"tare",
"target",
"tarheel",
"taricha",
"tariff",
"tarkovsky",
"tarmac",
"tarmacadam",
"tarn",
"tarnish",
"taro",
"tarot",
"tarp",
"tarpan",
"tarpaulin",
"tarpon",
"tarquin",
"tarquinius",
"tarradiddle",
"tarragon",
"tarriance",
"tarrietia",
"tarsal",
"tarsier",
"tarsiidae",
"tarsioidea",
"tarsitis",
"tarsius",
"tarsus",
"tart",
"tartan",
"tartar",
"tartarus",
"tartary",
"tartlet",
"tartness",
"tartrate",
"tartu",
"tartufe",
"tartuffe",
"tarweed",
"tarwood",
"tarzan",
"tashkent",
"tashmit",
"tashmitum",
"task",
"taskent",
"taskmaster",
"taskmistress",
"tasman",
"tasmania",
"tasse",
"tassel",
"tasset",
"tasso",
"taste",
"tastebud",
"tastefulness",
"tastelessness",
"taster",
"tastiness",
"tasting",
"tatahumara",
"tatar",
"tatary",
"tate",
"tater",
"tati",
"tatou",
"tatouay",
"tatter",
"tatterdemalion",
"tatting",
"tattle",
"tattler",
"tattletale",
"tattoo",
"tatu",
"tatum",
"taunt",
"taunting",
"tauon",
"taupe",
"taurine",
"tauromachy",
"taurotragus",
"taurus",
"tautness",
"tautog",
"tautoga",
"tautogolabrus",
"tautology",
"tavern",
"tawdriness",
"tawney",
"tawniness",
"tawse",
"taxability",
"taxaceae",
"taxales",
"taxation",
"taxer",
"taxi",
"taxicab",
"taxidea",
"taxidermist",
"taxidermy",
"taxidriver",
"taximan",
"taximeter",
"taxis",
"taxistand",
"taxiway",
"taxman",
"taxodiaceae",
"taxodium",
"taxon",
"taxonomer",
"taxonomist",
"taxonomy",
"taxophytina",
"taxopsida",
"taxpayer",
"taxus",
"tayalic",
"tayassu",
"tayassuidae",
"taylor",
"tayra",
"tazicef",
"tbilisi",
"tbit",
"tchad",
"tchaikovsky",
"tchotchke",
"tchotchkeleh",
"teaberry",
"teacake",
"teacart",
"teach",
"teacher",
"teachership",
"teaching",
"teacup",
"teacupful",
"teahouse",
"teak",
"teakettle",
"teakwood",
"teal",
"team",
"teammate",
"teamster",
"teamwork",
"teapot",
"tear",
"tearaway",
"teardrop",
"tearfulness",
"teargas",
"tearing",
"tearjerker",
"tearoom",
"tears",
"teasdale",
"tease",
"teasel",
"teaser",
"teashop",
"teasing",
"teasle",
"teaspoon",
"teaspoonful",
"teat",
"teatime",
"teazel",
"tebaldi",
"tebet",
"tebibit",
"tebibyte",
"tech",
"techie",
"technetium",
"technical",
"technicality",
"technician",
"technicolor",
"technique",
"techno",
"technobabble",
"technocracy",
"technocrat",
"technologist",
"technology",
"technophile",
"technophilia",
"technophobe",
"technophobia",
"tecophilaeacea",
"tectaria",
"tectona",
"tectonics",
"tecumseh",
"tecumtha",
"teddy",
"tediousness",
"tedium",
"teemingness",
"teen",
"teenager",
"teens",
"teeoff",
"teepee",
"teeter",
"teeterboard",
"teetertotter",
"teeth",
"teething",
"teetotaler",
"teetotaling",
"teetotalism",
"teetotalist",
"teetotaller",
"teetotum",
"teff",
"tefillin",
"teflon",
"tegu",
"tegucigalpa",
"tegument",
"teheran",
"tehran",
"teiid",
"teiidae",
"teju",
"tekki",
"tektite",
"telamon",
"telanthera",
"telco",
"telecast",
"telecaster",
"telecasting",
"telecom",
"telecommerce",
"telecommuting",
"teleconference",
"telefilm",
"telegnosis",
"telegram",
"telegraph",
"telegrapher",
"telegraphese",
"telegraphist",
"telegraphy",
"telekinesis",
"telemann",
"telemark",
"telemarketing",
"telemeter",
"telemetry",
"telencephalon",
"teleologist",
"teleology",
"teleost",
"teleostan",
"teleostei",
"telepathist",
"telepathy",
"telephone",
"telephoner",
"telephonist",
"telephony",
"telephoto",
"telephotograph",
"telephotography",
"teleportation",
"teleprinter",
"teleprocessing",
"teleprompter",
"telerobotics",
"telescope",
"telescopium",
"telescopy",
"teleselling",
"telethermometer",
"teletypewriter",
"televangelism",
"televangelist",
"television",
"teleworking",
"telex",
"telfer",
"telferage",
"telint",
"teliospore",
"tell",
"teller",
"tellima",
"telling",
"telltale",
"tellurian",
"telluride",
"tellurium",
"tellus",
"telly",
"telomerase",
"telomere",
"telopea",
"telophase",
"telosporidia",
"telpher",
"telpherage",
"telsontail",
"telugu",
"temazepam",
"temblor",
"temerity",
"temnospondyli",
"temp",
"temper",
"tempera",
"temperament",
"temperance",
"temperateness",
"temperature",
"tempering",
"tempest",
"tempestuousness",
"templar",
"template",
"temple",
"templet",
"templetonia",
"tempo",
"temporal",
"temporalis",
"temporality",
"temporalty",
"temporariness",
"temporary",
"temporiser",
"temporizer",
"tempra",
"temptation",
"tempter",
"temptingness",
"temptress",
"tempura",
"temuco",
"temujin",
"tenability",
"tenableness",
"tenaciousness",
"tenacity",
"tenancy",
"tenant",
"tenantry",
"tench",
"tendency",
"tendentiousness",
"tender",
"tenderfoot",
"tendergreen",
"tenderisation",
"tenderiser",
"tenderization",
"tenderizer",
"tenderloin",
"tenderness",
"tending",
"tendinitis",
"tendon",
"tendonitis",
"tendosynovitis",
"tendrac",
"tendril",
"tenebrionid",
"tenebrionidae",
"tenement",
"tenerife",
"tenesmus",
"tenet",
"tenge",
"tenia",
"tenner",
"tennessean",
"tennessee",
"tenniel",
"tennis",
"tenno",
"tennyson",
"tenon",
"tenonitis",
"tenor",
"tenoretic",
"tenorist",
"tenormin",
"tenoroon",
"tenosynovitis",
"tenpence",
"tenpin",
"tenpins",
"tenpounder",
"tenrec",
"tenrecidae",
"tense",
"tenseness",
"tensimeter",
"tensiometer",
"tension",
"tensity",
"tensor",
"tent",
"tentacle",
"tentaculata",
"tenter",
"tenterhook",
"tenth",
"tenthredinidae",
"tenting",
"tentmaker",
"tentorium",
"tenuity",
"tenure",
"tepal",
"tepee",
"tephrosia",
"tepic",
"tepidity",
"tepidness",
"tequila",
"tera",
"terabit",
"terabyte",
"teraflop",
"terahertz",
"teras",
"teratogen",
"teratogenesis",
"teratology",
"teratoma",
"terazosin",
"terbinafine",
"terbium",
"terce",
"tercel",
"tercelet",
"tercentenary",
"tercentennial",
"tercet",
"terebella",
"terebellidae",
"terebinth",
"teredinid",
"teredinidae",
"teredo",
"terence",
"terengganu",
"teres",
"teresa",
"tereshkova",
"tergiversation",
"tergiversator",
"teriyaki",
"term",
"termagant",
"termer",
"termes",
"terminal",
"termination",
"terminator",
"terminology",
"terminus",
"termite",
"termitidae",
"terms",
"tern",
"ternary",
"ternion",
"terpene",
"terpsichore",
"terpsichorean",
"terrace",
"terrain",
"terramycin",
"terrapene",
"terrapin",
"terrarium",
"terreplein",
"terribleness",
"terrier",
"terrietia",
"terrine",
"territorial",
"territoriality",
"territory",
"terror",
"terrorisation",
"terrorism",
"terrorist",
"terrorization",
"terry",
"terrycloth",
"terseness",
"tertiary",
"tertigravida",
"tertry",
"tertullian",
"terylene",
"terzetto",
"tesla",
"tessella",
"tessellation",
"tessera",
"tesseract",
"tessin",
"test",
"testa",
"testacea",
"testacean",
"testament",
"testate",
"testator",
"testatrix",
"testcross",
"testee",
"tester",
"testicle",
"testiere",
"testifier",
"testimonial",
"testimony",
"testiness",
"testing",
"testis",
"testosterone",
"testudinata",
"testudines",
"testudinidae",
"testudo",
"tetanilla",
"tetanus",
"tetany",
"tetartanopia",
"tetchiness",
"teth",
"tether",
"tetherball",
"tethyidae",
"tethys",
"teton",
"tetra",
"tetracaine",
"tetrachloride",
"tetraclinis",
"tetracycline",
"tetrad",
"tetragon",
"tetragonia",
"tetragoniaceae",
"tetragonurus",
"tetragram",
"tetragrammaton",
"tetrahalide",
"tetrahedron",
"tetrahymena",
"tetralogy",
"tetrameter",
"tetraneuris",
"tetranychid",
"tetranychidae",
"tetrao",
"tetraodontidae",
"tetraonidae",
"tetrapod",
"tetrapturus",
"tetrasaccharide",
"tetraskele",
"tetraskelion",
"tetrasporangium",
"tetraspore",
"tetrazzini",
"tetri",
"tetrode",
"tetrodotoxin",
"tetrose",
"tetroxide",
"tetryl",
"tetterwort",
"tettigoniid",
"tettigoniidae",
"teucrium",
"teuton",
"teutonist",
"tevere",
"tevet",
"tewkesbury",
"texan",
"texarkana",
"texas",
"text",
"textbook",
"textile",
"texture",
"thackeray",
"thaddaeus",
"thai",
"thailand",
"thalamus",
"thalarctos",
"thalassaemia",
"thalassemia",
"thalassoma",
"thales",
"thalia",
"thaliacea",
"thalictrum",
"thalidomide",
"thalidone",
"thallium",
"thallophyta",
"thallophyte",
"thallus",
"thalmencephalon",
"thalweg",
"thames",
"thammuz",
"thamnophilus",
"thamnophis",
"thanatology",
"thanatophobia",
"thanatopsis",
"thanatos",
"thane",
"thaneship",
"thankfulness",
"thanks",
"thanksgiving",
"tharp",
"thatch",
"thatcher",
"thatcherism",
"thatcherite",
"thaumatolatry",
"thaumaturge",
"thaumaturgist",
"thaumaturgy",
"thaw",
"thawing",
"thea",
"theaceae",
"theanthropism",
"theater",
"theatergoer",
"theatre",
"theatregoer",
"theatrical",
"theatricality",
"theban",
"thebe",
"thebes",
"theca",
"thecodont",
"thecodontia",
"theelin",
"theft",
"theia",
"theism",
"theist",
"thelarche",
"thelephoraceae",
"thelypteris",
"theme",
"themis",
"themistocles",
"then",
"thenar",
"theobid",
"theobroma",
"theocracy",
"theodicy",
"theodolite",
"theodosius",
"theogony",
"theologian",
"theologiser",
"theologist",
"theologizer",
"theology",
"theophany",
"theophrastaceae",
"theophrastus",
"theophylline",
"theorem",
"theoretician",
"theorisation",
"theoriser",
"theorist",
"theorization",
"theorizer",
"theory",
"theosophism",
"theosophist",
"theosophy",
"theoterrorism",
"therapeutic",
"therapeutics",
"theraphosidae",
"therapist",
"therapsid",
"therapsida",
"therapy",
"theravada",
"there",
"theremin",
"thereness",
"theresa",
"theridiid",
"theridiidae",
"therm",
"thermal",
"thermalgesia",
"thermel",
"thermidor",
"thermion",
"thermionics",
"thermistor",
"thermobia",
"thermocautery",
"thermochemistry",
"thermocouple",
"thermodynamics",
"thermogram",
"thermograph",
"thermography",
"thermojunction",
"thermometer",
"thermometry",
"thermopile",
"thermoplastic",
"thermopsis",
"thermopylae",
"thermoreceptor",
"thermoregulator",
"thermos",
"thermosphere",
"thermostat",
"thermostatics",
"thermotherapy",
"thermotropism",
"theropod",
"theropoda",
"thesaurus",
"theseus",
"thesis",
"thespesia",
"thespian",
"thespis",
"thessalia",
"thessalian",
"thessalonian",
"thessalonica",
"thessaloniki",
"thessaly",
"theta",
"thetis",
"theurgy",
"thevetia",
"thiabendazole",
"thiamin",
"thiamine",
"thiazide",
"thiazine",
"thibet",
"thick",
"thickener",
"thickening",
"thicket",
"thickhead",
"thickness",
"thief",
"thielavia",
"thievery",
"thieving",
"thievishness",
"thigh",
"thighbone",
"thill",
"thimble",
"thimbleberry",
"thimbleful",
"thimblerig",
"thimbleweed",
"thimerosal",
"thing",
"thingamabob",
"thingamajig",
"thingmabob",
"thingmajig",
"things",
"thingumabob",
"thingumajig",
"thingummy",
"think",
"thinker",
"thinking",
"thinner",
"thinness",
"thinning",
"thiobacillus",
"thiobacteria",
"thiocyanate",
"thioguanine",
"thiopental",
"thioridazine",
"thiosulfil",
"thiotepa",
"thiothixene",
"thiouracil",
"third",
"thirst",
"thirster",
"thirstiness",
"thirteen",
"thirteenth",
"thirties",
"thirtieth",
"thirty",
"thiry",
"thistle",
"thistledown",
"thlaspi",
"thole",
"tholepin",
"thomas",
"thomism",
"thomomys",
"thompson",
"thomson",
"thong",
"thor",
"thoracentesis",
"thoracocentesis",
"thoracotomy",
"thorax",
"thorazine",
"thoreau",
"thorite",
"thorium",
"thorn",
"thornbill",
"thorndike",
"thorniness",
"thornton",
"thoroughbred",
"thoroughfare",
"thoroughness",
"thoroughwort",
"thorpe",
"thorshavn",
"thortveitite",
"thoth",
"thou",
"thought",
"thoughtfulness",
"thoughtlessness",
"thousand",
"thousandth",
"thrace",
"thracian",
"thraldom",
"thrall",
"thralldom",
"thrash",
"thrasher",
"thrashing",
"thraupidae",
"thread",
"threader",
"threadfin",
"threadfish",
"threads",
"threadworm",
"threat",
"three",
"threepence",
"threescore",
"threesome",
"threnody",
"threonine",
"thresher",
"threshing",
"threshold",
"threskiornis",
"thrift",
"thriftiness",
"thriftlessness",
"thriftshop",
"thrill",
"thriller",
"thrinax",
"thrip",
"thripid",
"thripidae",
"thrips",
"throat",
"throatwort",
"throb",
"throbbing",
"throe",
"throes",
"thrombasthenia",
"thrombectomy",
"thrombin",
"thrombocyte",
"thrombocytosis",
"thromboembolism",
"thrombokinase",
"thrombolysis",
"thrombolytic",
"thrombopenia",
"thromboplastin",
"thrombosis",
"thrombus",
"throne",
"throng",
"throstle",
"throttle",
"throttlehold",
"throttler",
"throttling",
"throughput",
"throughway",
"throw",
"throwaway",
"throwback",
"thrower",
"throwster",
"thrum",
"thrush",
"thrust",
"thruster",
"thrusting",
"thruway",
"thryothorus",
"thucydides",
"thud",
"thug",
"thuggee",
"thuggery",
"thuja",
"thujopsis",
"thule",
"thulium",
"thumb",
"thumbhole",
"thumbnail",
"thumbnut",
"thumbprint",
"thumbscrew",
"thumbstall",
"thumbtack",
"thump",
"thumping",
"thunbergia",
"thunder",
"thunderbird",
"thunderbolt",
"thunderclap",
"thundercloud",
"thunderer",
"thunderhead",
"thundershower",
"thunderstorm",
"thunk",
"thunnus",
"thurber",
"thurible",
"thurifer",
"thuringia",
"thursday",
"thus",
"thwack",
"thwart",
"thwarter",
"thwarting",
"thylacine",
"thylacinus",
"thylogale",
"thyme",
"thymelaeaceae",
"thymelaeales",
"thymidine",
"thymine",
"thymol",
"thymosin",
"thymus",
"thyreophora",
"thyreophoran",
"thyrocalcitonin",
"thyroglobulin",
"thyroid",
"thyroidectomy",
"thyroiditis",
"thyromegaly",
"thyronine",
"thyroprotein",
"thyrotoxicosis",
"thyrotrophin",
"thyrotropin",
"thyroxin",
"thyroxine",
"thyrse",
"thyrsopteris",
"thyrsus",
"thysanocarpus",
"thysanopter",
"thysanoptera",
"thysanopteron",
"thysanura",
"thysanuron",
"tiamat",
"tianjin",
"tiara",
"tiarella",
"tiber",
"tiberius",
"tibet",
"tibetan",
"tibia",
"tibialis",
"tibicen",
"tibit",
"tibur",
"tical",
"tichodroma",
"tichodrome",
"ticino",
"tick",
"ticker",
"ticket",
"ticking",
"tickle",
"tickler",
"tickling",
"tickseed",
"ticktack",
"ticktacktoe",
"ticktacktoo",
"ticktock",
"tickweed",
"ticonderoga",
"tictac",
"tidbit",
"tiddler",
"tiddlywinks",
"tide",
"tideland",
"tidemark",
"tidewater",
"tideway",
"tidiness",
"tidings",
"tidy",
"tidytips",
"tieback",
"tiebreaker",
"tientsin",
"tiepin",
"tiepolo",
"tier",
"tierce",
"tiercel",
"tiff",
"tiffany",
"tiffin",
"tiflis",
"tiger",
"tigers",
"tightening",
"tightfistedness",
"tightness",
"tightrope",
"tights",
"tightwad",
"tiglon",
"tigon",
"tigress",
"tigris",
"tijuana",
"tike",
"tilapia",
"tilde",
"tilden",
"tile",
"tilefish",
"tiler",
"tilia",
"tiliaceae",
"tiling",
"tiliomycetes",
"till",
"tillage",
"tillandsia",
"tiller",
"tilletia",
"tilletiaceae",
"tillich",
"tilling",
"tilt",
"tilter",
"tilth",
"tiltyard",
"timalia",
"timaliidae",
"timbale",
"timber",
"timberland",
"timberline",
"timberman",
"timbre",
"timbrel",
"timbuktu",
"time",
"timecard",
"timekeeper",
"timekeeping",
"timelessness",
"timeline",
"timeliness",
"timepiece",
"timer",
"times",
"timeserver",
"timetable",
"timework",
"timgad",
"timid",
"timidity",
"timidness",
"timimoun",
"timing",
"timolol",
"timor",
"timorese",
"timorousness",
"timothy",
"timpani",
"timpanist",
"timucu",
"timur",
"tinamidae",
"tinamiformes",
"tinamou",
"tinbergen",
"tinca",
"tincture",
"tindal",
"tindale",
"tinder",
"tinderbox",
"tine",
"tinea",
"tineid",
"tineidae",
"tineoid",
"tineoidea",
"tineola",
"tinfoil",
"ting",
"tinge",
"tingidae",
"tingle",
"tingling",
"tininess",
"tinker",
"tinkerer",
"tinkle",
"tinner",
"tinning",
"tinnitus",
"tinplate",
"tinsel",
"tinsmith",
"tinsnips",
"tint",
"tintack",
"tinter",
"tinting",
"tintometer",
"tintoretto",
"tinware",
"tipi",
"tipper",
"tippet",
"tipple",
"tippler",
"tipsiness",
"tipstaff",
"tipster",
"tiptoe",
"tiptop",
"tipu",
"tipuana",
"tipulidae",
"tirade",
"tiramisu",
"tirana",
"tire",
"tiredness",
"tirelessness",
"tiresias",
"tiresomeness",
"tiro",
"tirol",
"tirolean",
"tisane",
"tishri",
"tisiphone",
"tissue",
"titan",
"titaness",
"titania",
"titanium",
"titanosaur",
"titanosaurian",
"titanosauridae",
"titanosaurus",
"titbit",
"titer",
"titfer",
"tithe",
"tither",
"tithonia",
"titi",
"titian",
"titillation",
"titivation",
"titlark",
"title",
"titmouse",
"tito",
"titration",
"titrator",
"titre",
"titter",
"titterer",
"tittivation",
"tittle",
"titty",
"titus",
"tivoli",
"tiyin",
"tizzy",
"tlingit",
"toad",
"toadfish",
"toadflax",
"toadshade",
"toadstool",
"toady",
"toast",
"toaster",
"toasting",
"toastmaster",
"toastrack",
"tobacco",
"tobacconist",
"tobago",
"tobagonian",
"tobey",
"tobin",
"tobit",
"toboggan",
"tobogganing",
"tobogganist",
"tobramycin",
"toby",
"tocainide",
"tocantins",
"toccata",
"tocharian",
"tocktact",
"tocology",
"tocopherol",
"tocqueville",
"tocsin",
"toda",
"today",
"todd",
"toddler",
"toddy",
"todea",
"todidae",
"todus",
"tody",
"toea",
"toecap",
"toehold",
"toenail",
"toetoe",
"toff",
"toffee",
"toffy",
"tofieldia",
"tofranil",
"tofu",
"toga",
"togaviridae",
"togetherness",
"toggle",
"togo",
"togolese",
"togs",
"toil",
"toiler",
"toilet",
"toiletry",
"toilette",
"toilsomeness",
"toitoi",
"tojo",
"tokamak",
"tokay",
"toke",
"token",
"tokio",
"toklas",
"tokyo",
"tolazamide",
"tolazoline",
"tolbooth",
"tolbukhin",
"tolbutamide",
"tole",
"tolectin",
"toledo",
"tolerance",
"toleration",
"tolinase",
"tolkien",
"toll",
"tollbar",
"tollbooth",
"toller",
"tollgate",
"tollgatherer",
"tollhouse",
"tollkeeper",
"tollman",
"tollon",
"tolmiea",
"tolstoy",
"toltec",
"tolu",
"toluene",
"tolypeutes",
"tomahawk",
"tomalley",
"tomatillo",
"tomato",
"tomb",
"tombac",
"tombak",
"tombaugh",
"tombigbee",
"tombola",
"tomboy",
"tomboyishness",
"tombstone",
"tomcat",
"tome",
"tomentum",
"tomfool",
"tomfoolery",
"tomistoma",
"tommyrot",
"tomograph",
"tomography",
"tomorrow",
"tompion",
"tomtate",
"tomtit",
"tonality",
"tone",
"toner",
"tonga",
"tongan",
"tongs",
"tongue",
"tonguefish",
"tongueflower",
"tonic",
"tonicity",
"tonight",
"tonnage",
"tonne",
"tonocard",
"tonometer",
"tonometry",
"tons",
"tonsil",
"tonsilla",
"tonsillectomy",
"tonsillitis",
"tonsure",
"tontine",
"tonus",
"tool",
"toolbox",
"toolhouse",
"toolmaker",
"toolshed",
"toon",
"toona",
"tooshie",
"toot",
"tooth",
"toothache",
"toothbrush",
"toothpaste",
"toothpick",
"toothpowder",
"toothsomeness",
"toothwort",
"tootle",
"topaz",
"topcoat",
"tope",
"topee",
"topeka",
"toper",
"topgallant",
"tophus",
"topi",
"topiary",
"topic",
"topicality",
"topicalization",
"topknot",
"topmast",
"topminnow",
"topognosia",
"topognosis",
"topography",
"topolatry",
"topology",
"toponomy",
"toponym",
"toponymy",
"topos",
"topper",
"topping",
"topsail",
"topside",
"topsoil",
"topspin",
"topv",
"toque",
"toradol",
"torah",
"torch",
"torchbearer",
"torchlight",
"tore",
"toreador",
"torero",
"torino",
"torment",
"tormenter",
"tormentor",
"tornado",
"tornillo",
"torodal",
"toroid",
"toronto",
"torpedinidae",
"torpediniformes",
"torpedo",
"torpidity",
"torpidness",
"torpor",
"torque",
"torquemada",
"torr",
"torrent",
"torreon",
"torreya",
"torricelli",
"torridity",
"torsion",
"torsk",
"torso",
"tort",
"torte",
"tortellini",
"tortfeasor",
"torticollis",
"tortilla",
"tortoise",
"tortoiseshell",
"tortricid",
"tortricidae",
"tortrix",
"tortuosity",
"tortuousness",
"torture",
"torturer",
"torturing",
"torus",
"tory",
"toscana",
"toscanini",
"tosh",
"tosk",
"toss",
"tosser",
"tossup",
"tostada",
"total",
"totalisator",
"totaliser",
"totalism",
"totalitarian",
"totalitarianism",
"totality",
"totalizator",
"totalizer",
"totara",
"tote",
"totem",
"totemism",
"totemist",
"toter",
"totipotence",
"totipotency",
"totterer",
"toucan",
"toucanet",
"touch",
"touchback",
"touchdown",
"toucher",
"touchiness",
"touching",
"touchline",
"touchscreen",
"touchstone",
"touchwood",
"tough",
"toughie",
"toughness",
"toulon",
"toulouse",
"toupe",
"toupee",
"tour",
"touraco",
"tourer",
"tourette",
"tourism",
"tourist",
"touristry",
"tourmaline",
"tournament",
"tournedos",
"tourney",
"tourniquet",
"tours",
"tourtiere",
"tout",
"touter",
"tovarich",
"tovarisch",
"towage",
"towboat",
"towel",
"toweling",
"towelling",
"tower",
"towhead",
"towhee",
"towline",
"town",
"townee",
"towner",
"townes",
"townie",
"townsend",
"townsendia",
"townsfolk",
"township",
"townsman",
"townspeople",
"towny",
"towpath",
"towrope",
"toxaemia",
"toxemia",
"toxicant",
"toxicity",
"toxicodendron",
"toxicognath",
"toxicologist",
"toxicology",
"toxin",
"toxoid",
"toxoplasmosis",
"toxostoma",
"toxotes",
"toxotidae",
"toying",
"toynbee",
"toyohashi",
"toyon",
"toyonaki",
"toyota",
"toyshop",
"trabecula",
"trablous",
"trace",
"tracer",
"tracery",
"trachea",
"tracheid",
"tracheitis",
"trachelospermum",
"tracheophyta",
"tracheophyte",
"tracheostomy",
"tracheotomy",
"trachinotus",
"trachipteridae",
"trachipterus",
"trachodon",
"trachodont",
"trachoma",
"trachurus",
"tracing",
"track",
"trackball",
"tracker",
"tracking",
"tracklayer",
"tract",
"tractability",
"tractableness",
"tractarian",
"tractarianism",
"traction",
"tractor",
"tracy",
"trad",
"trade",
"tradecraft",
"trademark",
"tradeoff",
"trader",
"tradescant",
"tradescantia",
"tradesman",
"tradespeople",
"trading",
"tradition",
"traditionalism",
"traditionalist",
"traditionality",
"traducement",
"traducer",
"trafalgar",
"traffic",
"trafficator",
"trafficker",
"tragacanth",
"tragedian",
"tragedienne",
"tragedy",
"tragelaphus",
"tragicomedy",
"tragopan",
"tragopogon",
"tragulidae",
"tragulus",
"tragus",
"trail",
"trailblazer",
"trailer",
"trailhead",
"trailing",
"train",
"trainband",
"trainbandsman",
"trainbearer",
"trainee",
"traineeship",
"trainer",
"training",
"trainload",
"trainman",
"trainmaster",
"trait",
"traitor",
"traitorousness",
"traitress",
"trajan",
"trajectory",
"tram",
"tramcar",
"tramline",
"trammel",
"tramontana",
"tramontane",
"tramp",
"tramper",
"trample",
"trampler",
"trampling",
"trampoline",
"tramway",
"trance",
"tranche",
"trandate",
"trandolapril",
"tranquility",
"tranquilizer",
"tranquilliser",
"tranquillity",
"tranquillizer",
"transactinide",
"transaction",
"transactions",
"transactor",
"transalpine",
"transaminase",
"transamination",
"transcaucasia",
"transcendence",
"transcendency",
"transcriber",
"transcript",
"transcriptase",
"transcription",
"transducer",
"transduction",
"transept",
"transexual",
"transfer",
"transferability",
"transferase",
"transferee",
"transference",
"transferer",
"transferor",
"transferral",
"transferrer",
"transferrin",
"transfiguration",
"transformation",
"transformer",
"transfusion",
"transgendered",
"transgene",
"transgression",
"transgressor",
"transience",
"transiency",
"transient",
"transistor",
"transit",
"transition",
"transitive",
"transitiveness",
"transitivity",
"transitoriness",
"translation",
"translator",
"transliteration",
"translocation",
"translucence",
"translucency",
"transmigrante",
"transmigration",
"transmission",
"transmittal",
"transmittance",
"transmitter",
"transmitting",
"transmutability",
"transmutation",
"transom",
"transparence",
"transparency",
"transparentness",
"transpiration",
"transplant",
"transplantation",
"transplanter",
"transplanting",
"transponder",
"transport",
"transportation",
"transporter",
"transposability",
"transpose",
"transposition",
"transposon",
"transsexual",
"transsexualism",
"transshipment",
"transudate",
"transudation",
"transvaal",
"transvestism",
"transvestite",
"transvestitism",
"transylvania",
"tranylcypromine",
"trap",
"trapa",
"trapaceae",
"trapeze",
"trapezium",
"trapezius",
"trapezohedron",
"trapezoid",
"trapper",
"trapping",
"trappings",
"trappist",
"trapshooter",
"trapshooting",
"trash",
"trashiness",
"trasimeno",
"traubel",
"trauma",
"traumatology",
"traumatophobia",
"trautvetteria",
"travail",
"trave",
"travel",
"traveler",
"traveling",
"traveller",
"travelling",
"travelog",
"travelogue",
"traversal",
"traverse",
"traverser",
"travesty",
"trawl",
"trawler",
"tray",
"trazodone",
"treachery",
"treacle",
"tread",
"treadle",
"treadmill",
"treadwheel",
"treason",
"treasonist",
"treasure",
"treasurer",
"treasurership",
"treasury",
"treat",
"treater",
"treatise",
"treatment",
"treaty",
"treble",
"trebuchet",
"trebucket",
"tree",
"treehopper",
"treelet",
"treenail",
"treetop",
"trefoil",
"treillage",
"trek",
"trekker",
"trellis",
"trema",
"trematoda",
"trematode",
"tremble",
"trembler",
"trembles",
"trembling",
"tremella",
"tremellaceae",
"tremellales",
"tremolite",
"tremolo",
"tremor",
"trenail",
"trench",
"trenchancy",
"trencher",
"trencherman",
"trend",
"trent",
"trental",
"trento",
"trenton",
"trepan",
"trepang",
"trephination",
"trephine",
"trephritidae",
"trepidation",
"treponema",
"treponemataceae",
"trespass",
"trespasser",
"tress",
"trestle",
"trestlework",
"trevelyan",
"trevino",
"trevithick",
"trews",
"trey",
"triacetate",
"triad",
"triaenodon",
"triage",
"triakidae",
"trial",
"trialeurodes",
"triamcinolone",
"triangle",
"triangularity",
"triangulation",
"triangulum",
"triassic",
"triatoma",
"triavil",
"triazine",
"triazolam",
"tribade",
"tribadism",
"tribalisation",
"tribalism",
"tribalization",
"tribe",
"tribesman",
"tribolium",
"tribologist",
"tribology",
"tribonema",
"tribonemaceae",
"tribromoethanol",
"tribromomethane",
"tribulation",
"tribulus",
"tribunal",
"tribune",
"tribuneship",
"tributary",
"tribute",
"tributyrin",
"trice",
"triceps",
"triceratops",
"trichechidae",
"trichechus",
"trichina",
"trichiniasis",
"trichinosis",
"trichion",
"trichiuridae",
"trichloride",
"trichloroethane",
"trichobezoar",
"trichoceros",
"trichodesmium",
"trichodontidae",
"trichoglossus",
"tricholoma",
"trichomanes",
"trichomonad",
"trichomoniasis",
"trichophaga",
"trichophyton",
"trichoptera",
"trichopteran",
"trichopteron",
"trichostema",
"trichostigma",
"trichosurus",
"trichotomy",
"trichroism",
"trichromacy",
"trichuriasis",
"trichys",
"trick",
"tricker",
"trickery",
"trickiness",
"trickle",
"trickster",
"triclinium",
"tricolor",
"tricolour",
"tricorn",
"tricorne",
"tricot",
"tricycle",
"tricyclic",
"tridacna",
"tridacnidae",
"trident",
"tridymite",
"triennial",
"trier",
"trifle",
"trifler",
"trifling",
"trifoliata",
"trifolium",
"trifurcation",
"trig",
"triga",
"trigeminal",
"trigeminus",
"trigger",
"triggerfish",
"triggerman",
"triglidae",
"triglinae",
"triglochin",
"triglyceride",
"trigon",
"trigonella",
"trigonometry",
"trigram",
"triiodomethane",
"trike",
"trilateral",
"trilby",
"trilisa",
"trill",
"trilliaceae",
"trilling",
"trillion",
"trillionth",
"trillium",
"trilobite",
"trilogy",
"trim",
"trimaran",
"trimer",
"trimester",
"trimipramine",
"trimmer",
"trimming",
"trimmings",
"trimness",
"trimorphodon",
"trimox",
"trimurti",
"trine",
"trinectes",
"tringa",
"trinidad",
"trinidadian",
"trinitarian",
"trinitarianism",
"trinitrotoluene",
"trinity",
"trinket",
"trinketry",
"trio",
"triode",
"triolein",
"trionychidae",
"trionyx",
"triopidae",
"triops",
"triose",
"triostium",
"trioxide",
"trip",
"tripalmitin",
"tripe",
"triphammer",
"triple",
"triplet",
"tripletail",
"triplicate",
"triplicity",
"tripling",
"triplochiton",
"tripod",
"tripoli",
"tripos",
"tripper",
"triptych",
"triquetral",
"trireme",
"trisaccharide",
"triskele",
"triskelion",
"trismus",
"trisomy",
"tristan",
"tristearin",
"tristram",
"trisyllable",
"tritanopia",
"triteness",
"tritheism",
"tritheist",
"triticum",
"tritium",
"tritoma",
"triton",
"triturus",
"triumph",
"triumvir",
"triumvirate",
"trivet",
"trivia",
"triviality",
"trivium",
"trna",
"trochanter",
"troche",
"trochee",
"trochilidae",
"trochlear",
"trochlearis",
"trogium",
"troglodyte",
"troglodytes",
"troglodytidae",
"trogon",
"trogonidae",
"trogoniformes",
"troika",
"trojan",
"troll",
"troller",
"trolley",
"trolleybus",
"trolling",
"trollius",
"trollop",
"trollope",
"trombicula",
"trombiculiasis",
"trombiculid",
"trombiculidae",
"trombidiid",
"trombidiidae",
"trombone",
"trombonist",
"trompillo",
"trondheim",
"troop",
"trooper",
"troops",
"troopship",
"tropaeolaceae",
"tropaeolum",
"trope",
"trophobiosis",
"trophoblast",
"trophotropism",
"trophozoite",
"trophy",
"tropic",
"tropicbird",
"tropics",
"tropidoclonion",
"tropism",
"troponomy",
"troponym",
"troponymy",
"tropopause",
"troposphere",
"trot",
"troth",
"trotline",
"trotsky",
"trotskyism",
"trotskyist",
"trotskyite",
"trotter",
"troubadour",
"trouble",
"troublemaker",
"troubler",
"troubleshooter",
"troublesomeness",
"trough",
"trouncing",
"troupe",
"trouper",
"trouser",
"trousering",
"trousers",
"trousseau",
"trout",
"trove",
"trowel",
"troy",
"truancy",
"truant",
"truce",
"truck",
"truckage",
"trucker",
"trucking",
"truckle",
"truckler",
"truckling",
"truculence",
"truculency",
"trudge",
"trudger",
"true",
"truelove",
"trueness",
"truffaut",
"truffle",
"truism",
"truman",
"trumbo",
"trumbull",
"trump",
"trumpery",
"trumpet",
"trumpeter",
"trumpetfish",
"trumpets",
"trumpetwood",
"trumping",
"truncation",
"truncheon",
"truncocolumella",
"trundle",
"trunk",
"trunkfish",
"trunks",
"trunnel",
"truss",
"trust",
"trustbuster",
"trustee",
"trusteeship",
"truster",
"trustfulness",
"trustiness",
"trustingness",
"trustor",
"trustworthiness",
"trusty",
"truth",
"truthfulness",
"tryout",
"trypetidae",
"trypsin",
"trypsinogen",
"tryptophan",
"tryptophane",
"tryst",
"tsar",
"tsarina",
"tsaritsa",
"tsaritsyn",
"tsatske",
"tsetse",
"tshatshke",
"tshiluba",
"tsimshian",
"tsine",
"tsoris",
"tsouic",
"tsuga",
"tsunami",
"tsuris",
"tsushima",
"tswana",
"tuareg",
"tuatara",
"tuba",
"tubbiness",
"tube",
"tubeless",
"tuber",
"tuberaceae",
"tuberales",
"tubercle",
"tubercular",
"tubercularia",
"tuberculin",
"tuberculosis",
"tuberose",
"tuberosity",
"tubful",
"tubing",
"tubman",
"tubocurarine",
"tubule",
"tubulidentata",
"tucana",
"tuchman",
"tuck",
"tuckahoe",
"tucker",
"tucket",
"tucson",
"tudor",
"tudung",
"tues",
"tuesday",
"tufa",
"tuff",
"tuffet",
"tuft",
"tugboat",
"tugela",
"tugger",
"tughrik",
"tugrik",
"tuileries",
"tuille",
"tuition",
"tularaemia",
"tularemia",
"tulestoma",
"tulip",
"tulipa",
"tulipwood",
"tulle",
"tully",
"tulostoma",
"tulostomaceae",
"tulostomataceae",
"tulostomatales",
"tulsa",
"tulu",
"tumble",
"tumblebug",
"tumbler",
"tumbleweed",
"tumbling",
"tumbrel",
"tumbril",
"tumefaction",
"tumescence",
"tumidity",
"tumidness",
"tummy",
"tumor",
"tumour",
"tums",
"tumult",
"tumultuousness",
"tumulus",
"tuna",
"tunaburger",
"tundra",
"tune",
"tunefulness",
"tuner",
"tung",
"tunga",
"tungstate",
"tungsten",
"tungus",
"tungusic",
"tunguska",
"tunguz",
"tunic",
"tunica",
"tunicata",
"tunicate",
"tuning",
"tunis",
"tunisia",
"tunisian",
"tunker",
"tunnage",
"tunnel",
"tunney",
"tunny",
"tupaia",
"tupaiidae",
"tupek",
"tupelo",
"tupi",
"tupik",
"tupinambis",
"tuppence",
"tupungatito",
"tupungato",
"turaco",
"turacou",
"turakoo",
"turban",
"turbatrix",
"turbellaria",
"turbidity",
"turbidness",
"turbinal",
"turbinate",
"turbine",
"turbofan",
"turbogenerator",
"turbojet",
"turboprop",
"turbot",
"turbulence",
"turbulency",
"turcoman",
"turd",
"turdidae",
"turdinae",
"turdus",
"tureen",
"turf",
"turfan",
"turgenev",
"turgidity",
"turgidness",
"turgor",
"turgot",
"turin",
"turing",
"turk",
"turkestan",
"turkey",
"turki",
"turkic",
"turkish",
"turkistan",
"turkmen",
"turkmenia",
"turkmenistan",
"turkoman",
"turkomen",
"turmeric",
"turmoil",
"turn",
"turnabout",
"turnaround",
"turnbuckle",
"turncoat",
"turncock",
"turndown",
"turner",
"turnery",
"turnicidae",
"turning",
"turnip",
"turnix",
"turnkey",
"turnoff",
"turnout",
"turnover",
"turnpike",
"turnround",
"turnspit",
"turnstile",
"turnstone",
"turntable",
"turnup",
"turnverein",
"turp",
"turpentine",
"turpin",
"turpitude",
"turps",
"turquoise",
"turreae",
"turret",
"turritis",
"tursiops",
"turtle",
"turtledove",
"turtlehead",
"turtleneck",
"turtler",
"tuscaloosa",
"tuscan",
"tuscany",
"tuscarora",
"tush",
"tushery",
"tusk",
"tuskegee",
"tusker",
"tussah",
"tussaud",
"tusseh",
"tusser",
"tussilago",
"tussle",
"tussock",
"tussore",
"tussur",
"tutankhamen",
"tutee",
"tutelage",
"tutelo",
"tutor",
"tutorial",
"tutorship",
"tutsan",
"tutsi",
"tutu",
"tuvalu",
"tuxedo",
"twaddle",
"twaddler",
"twain",
"twang",
"twat",
"twayblade",
"tweak",
"tweed",
"tweediness",
"tweet",
"tweeter",
"tweezer",
"twelfth",
"twelfthtide",
"twelve",
"twelvemonth",
"twenties",
"twentieth",
"twenty",
"twerp",
"twiddle",
"twiddler",
"twig",
"twilight",
"twill",
"twin",
"twinberry",
"twine",
"twiner",
"twinflower",
"twinge",
"twinjet",
"twinkie",
"twinkle",
"twinkler",
"twinkling",
"twins",
"twirl",
"twirler",
"twirp",
"twist",
"twister",
"twisting",
"twistwood",
"twit",
"twitch",
"twitching",
"twitter",
"twitterer",
"twofer",
"twopence",
"twosome",
"tyche",
"tycoon",
"tying",
"tyiyn",
"tyke",
"tylenchidae",
"tylenchus",
"tylenol",
"tyler",
"tympan",
"tympani",
"tympanist",
"tympanites",
"tympanitis",
"tympanoplasty",
"tympanuchus",
"tympanum",
"tyndale",
"tyndall",
"tyne",
"type",
"typeface",
"typescript",
"typesetter",
"typewriter",
"typewriting",
"typha",
"typhaceae",
"typhlopidae",
"typhoeus",
"typhoid",
"typhon",
"typhoon",
"typhus",
"typicality",
"typification",
"typing",
"typist",
"typo",
"typographer",
"typography",
"typology",
"tyramine",
"tyranni",
"tyrannicide",
"tyrannid",
"tyrannidae",
"tyrannosaur",
"tyrannosaurus",
"tyrannus",
"tyranny",
"tyrant",
"tyre",
"tyro",
"tyrocidin",
"tyrocidine",
"tyrol",
"tyrolean",
"tyrosine",
"tyrosinemia",
"tyrothricin",
"tyrr",
"tyson",
"tyto",
"tytonidae",
"tzar",
"tzara",
"tzarina",
"tzetze",
"uakari",
"ubermensch",
"ubiety",
"ubiquinone",
"ubiquitousness",
"ubiquity",
"ubykh",
"udder",
"udmurt",
"udometer",
"uganda",
"ugandan",
"ugaritic",
"ugli",
"ugliness",
"ugrian",
"ugric",
"uhland",
"uighur",
"uigur",
"uintathere",
"uintatheriidae",
"uintatherium",
"ukase",
"ukraine",
"ukrainian",
"ukranian",
"ukrayina",
"ukulele",
"ulaanbaatar",
"ulalgia",
"ulama",
"ulanova",
"ulatrophia",
"ulcer",
"ulceration",
"ulema",
"ulemorrhagia",
"ulex",
"ulfila",
"ulfilas",
"ulitis",
"ullage",
"ullr",
"ulmaceae",
"ulmus",
"ulna",
"ulster",
"ulteriority",
"ultima",
"ultimacy",
"ultimate",
"ultimateness",
"ultimatum",
"ultracef",
"ultracentrifuge",
"ultramarine",
"ultramicroscope",
"ultramontane",
"ultramontanism",
"ultrasonography",
"ultrasound",
"ultrasuede",
"ultraviolet",
"ululation",
"ulva",
"ulvaceae",
"ulvales",
"ulvophyceae",
"ulysses",
"umayyad",
"umbel",
"umbellales",
"umbellifer",
"umbelliferae",
"umbellularia",
"umber",
"umbilical",
"umbilicus",
"umbo",
"umbra",
"umbrage",
"umbrella",
"umbrellawort",
"umbria",
"umbrian",
"umbrina",
"umbundu",
"umlaut",
"umma",
"ummah",
"umpirage",
"umpire",
"unabridged",
"unacceptability",
"unadaptability",
"unaffectedness",
"unai",
"unalterability",
"unambiguity",
"unanimity",
"unassertiveness",
"unassumingness",
"unau",
"unavailability",
"unavoidability",
"unawareness",
"unbalance",
"unbecomingness",
"unbelief",
"unboundedness",
"unbreakableness",
"uncertainness",
"uncertainty",
"unchangeability",
"unchangingness",
"uncheerfulness",
"uncial",
"uncle",
"uncleanliness",
"uncleanness",
"unclearness",
"uncloudedness",
"uncommonness",
"unconcern",
"unconfessed",
"uncongeniality",
"unconnectedness",
"unconscious",
"unconsciousness",
"unconstraint",
"uncouthness",
"uncovering",
"uncreativeness",
"unction",
"unctuousness",
"uncus",
"undecagon",
"undependability",
"underachiever",
"underbelly",
"underbodice",
"underbody",
"underboss",
"underbrush",
"undercarriage",
"undercharge",
"underclass",
"underclassman",
"underclothes",
"underclothing",
"undercoat",
"undercurrent",
"undercut",
"underdog",
"underdrawers",
"underestimate",
"underestimation",
"underevaluation",
"underexposure",
"underfelt",
"underframe",
"underfur",
"undergarment",
"undergrad",
"undergraduate",
"underground",
"undergrowth",
"underlay",
"underlayment",
"underline",
"underling",
"underlip",
"underpants",
"underpart",
"underpass",
"underpayment",
"underperformer",
"underproduction",
"underrating",
"underreckoning",
"underscore",
"underseal",
"undersecretary",
"underseller",
"undershirt",
"undershrub",
"underside",
"underskirt",
"undersoil",
"understanding",
"understatement",
"understructure",
"understudy",
"undersurface",
"undertaker",
"undertaking",
"undertide",
"undertone",
"undertow",
"undervaluation",
"underwear",
"underwing",
"underwood",
"underworld",
"underwriter",
"undesirability",
"undesirable",
"undies",
"undine",
"undiscipline",
"undoer",
"undoing",
"undress",
"undset",
"undulation",
"undutifulness",
"unease",
"uneasiness",
"unemotionality",
"unemployed",
"unemployment",
"unenlightenment",
"unequivocalness",
"unesco",
"unevenness",
"unexpectedness",
"unfairness",
"unfaithfulness",
"unfamiliarity",
"unfastener",
"unfastening",
"unfavorableness",
"unfeasibility",
"unfeelingness",
"unfitness",
"unfolding",
"unfortunate",
"unfriendliness",
"ungainliness",
"ungodliness",
"ungracefulness",
"ungraciousness",
"ungratefulness",
"unguent",
"unguiculata",
"unguiculate",
"unguis",
"ungulata",
"ungulate",
"unhappiness",
"unhealthfulness",
"unhealthiness",
"unhelpfulness",
"unholiness",
"unhurriedness",
"uniat",
"uniate",
"unicef",
"unicorn",
"unicycle",
"unicyclist",
"unification",
"uniform",
"uniformity",
"uniformness",
"unilateralism",
"unilateralist",
"unimportance",
"uninitiate",
"uninsurability",
"unio",
"union",
"unionidae",
"unionisation",
"unionism",
"unionist",
"unionization",
"uniqueness",
"unison",
"unit",
"unitard",
"unitarian",
"unitarianism",
"uniting",
"unitisation",
"unitization",
"unity",
"univalve",
"universal",
"universalism",
"universality",
"universe",
"university",
"unix",
"unjustness",
"unkemptness",
"unkindness",
"unknowing",
"unknowingness",
"unknown",
"unlawfulness",
"unlikelihood",
"unlikeliness",
"unlikeness",
"unloading",
"unmalleability",
"unmanliness",
"unmasking",
"unmentionable",
"unmercifulness",
"unmindfulness",
"unnaturalness",
"unnilquadium",
"unobtrusiveness",
"unoriginality",
"unorthodoxy",
"unpalatability",
"unpalatableness",
"unperson",
"unpleasantness",
"unpleasingness",
"unpointedness",
"unpopularity",
"unprofitability",
"unprotectedness",
"unraveler",
"unraveller",
"unrealism",
"unreality",
"unreason",
"unregularity",
"unrelatedness",
"unreliability",
"unreliableness",
"unrest",
"unrestraint",
"unrighteousness",
"unruliness",
"unsanitariness",
"unsavoriness",
"unseemliness",
"unseen",
"unselfishness",
"unsightliness",
"unsimilarity",
"unskillfulness",
"unsnarling",
"unsociability",
"unsociableness",
"unsolvability",
"unsoundness",
"unstableness",
"unsteadiness",
"unsuitability",
"unsuitableness",
"untangling",
"untermeyer",
"untidiness",
"untier",
"untimeliness",
"untouchable",
"untrustiness",
"untruth",
"untruthfulness",
"untying",
"untypicality",
"ununbium",
"ununhexium",
"ununpentium",
"ununquadium",
"ununtrium",
"unusefulness",
"unusualness",
"unvariedness",
"unveiling",
"unwariness",
"unwellness",
"unwholesomeness",
"unwieldiness",
"unwillingness",
"unwiseness",
"unworthiness",
"unyieldingness",
"upanishad",
"upbeat",
"upbraider",
"upbraiding",
"upbringing",
"upcast",
"update",
"updating",
"updike",
"updraft",
"upending",
"upgrade",
"upheaval",
"uphill",
"upholder",
"upholsterer",
"upholstery",
"upjohn",
"upkeep",
"upland",
"uplift",
"uplifting",
"uplink",
"upper",
"uppercase",
"uppercut",
"uppishness",
"uppityness",
"uppp",
"uppsala",
"upright",
"uprightness",
"uprising",
"uproar",
"uprooter",
"upsala",
"upset",
"upsetter",
"upshot",
"upside",
"upsilon",
"upstage",
"upstager",
"upstairs",
"upstart",
"upstroke",
"upsurge",
"uptake",
"upthrow",
"upthrust",
"uptick",
"uptime",
"uptown",
"upturn",
"upupa",
"upupidae",
"uracil",
"uraemia",
"uralic",
"urals",
"uranalysis",
"urania",
"uraninite",
"uranium",
"uranologist",
"uranology",
"uranoplasty",
"uranoscopidae",
"uranus",
"uranyl",
"urarthritis",
"urate",
"uratemia",
"uraturia",
"urbana",
"urbanisation",
"urbanity",
"urbanization",
"urceole",
"urchin",
"urdu",
"urea",
"urease",
"uredinales",
"uremia",
"ureter",
"ureteritis",
"ureterocele",
"ureterostenosis",
"urethane",
"urethra",
"urethritis",
"urethrocele",
"urex",
"urey",
"urga",
"urge",
"urgency",
"urginea",
"urging",
"uria",
"uriah",
"urial",
"uricaciduria",
"urinal",
"urinalysis",
"urination",
"urinator",
"urine",
"urmia",
"urobilin",
"urobilinogen",
"urocele",
"urochesia",
"urochezia",
"urochord",
"urochorda",
"urochordata",
"urochordate",
"urocyon",
"urocystis",
"urodele",
"urodella",
"urodynia",
"urokinase",
"urolith",
"urologist",
"urology",
"uropathy",
"urophycis",
"uropsilus",
"uropygi",
"uropygium",
"urosaurus",
"ursidae",
"ursinia",
"ursus",
"urth",
"urtica",
"urticaceae",
"urticales",
"urticaria",
"urtication",
"urubupunga",
"uruguay",
"uruguayan",
"urus",
"usability",
"usableness",
"usacil",
"usaf",
"usage",
"usance",
"usbeg",
"usbek",
"uscb",
"usda",
"useableness",
"usefulness",
"uselessness",
"user",
"ushas",
"usher",
"usherette",
"using",
"uskub",
"usmc",
"usnea",
"usneaceae",
"usps",
"ussher",
"ussr",
"usss",
"ustilaginaceae",
"ustilaginales",
"ustilaginoidea",
"ustilago",
"ustinov",
"usualness",
"usufruct",
"usufructuary",
"usuli",
"usumbura",
"usurer",
"usurpation",
"usurper",
"usury",
"utah",
"utahan",
"utahraptor",
"utensil",
"uterus",
"utica",
"utilisation",
"utiliser",
"utilitarian",
"utilitarianism",
"utility",
"utilization",
"utilizer",
"utmost",
"utnapishtim",
"utopia",
"utopian",
"utopianism",
"utrecht",
"utricle",
"utricularia",
"utriculus",
"utrillo",
"utterance",
"utterer",
"uttermost",
"utterness",
"utug",
"uvea",
"uveitis",
"uvula",
"uvularia",
"uvulariaceae",
"uvulitis",
"uxor",
"uxoricide",
"uxoriousness",
"uygur",
"uzbak",
"uzbeg",
"uzbek",
"uzbekistan",
"vacancy",
"vacation",
"vacationer",
"vacationing",
"vacationist",
"vacay",
"vaccaria",
"vaccina",
"vaccinating",
"vaccination",
"vaccinator",
"vaccine",
"vaccinee",
"vaccinia",
"vaccinium",
"vaccinum",
"vacillation",
"vacillator",
"vacuity",
"vacuolation",
"vacuole",
"vacuolisation",
"vacuolization",
"vacuousness",
"vacuum",
"vaduz",
"vagabond",
"vagabondage",
"vagary",
"vagina",
"vaginismus",
"vaginitis",
"vaginocele",
"vagrancy",
"vagrant",
"vagueness",
"vagus",
"vainglory",
"vaisakha",
"vaishnava",
"vaishnavism",
"vaisnavism",
"vaisya",
"vajra",
"valance",
"valdecoxib",
"valdez",
"valdosta",
"vale",
"valediction",
"valedictorian",
"valedictory",
"valence",
"valencia",
"valenciennes",
"valency",
"valentine",
"valerian",
"valeriana",
"valerianaceae",
"valerianella",
"valet",
"valetta",
"valetudinarian",
"valgus",
"valhalla",
"vali",
"valiance",
"valiancy",
"validation",
"validity",
"validness",
"valine",
"valise",
"valium",
"valkyrie",
"vallecula",
"valletta",
"valley",
"vallisneria",
"valmy",
"valois",
"valor",
"valorousness",
"valour",
"valparaiso",
"valsartan",
"valse",
"valuable",
"valuableness",
"valuation",
"valuator",
"value",
"valuelessness",
"valuer",
"values",
"valve",
"valvelet",
"valvotomy",
"valvula",
"valvule",
"valvulitis",
"valvulotomy",
"vambrace",
"vamp",
"vamper",
"vampire",
"vampirism",
"vanadate",
"vanadinite",
"vanadium",
"vanbrugh",
"vancocin",
"vancomycin",
"vancouver",
"vanda",
"vandal",
"vandalism",
"vanderbilt",
"vandyke",
"vane",
"vanellus",
"vanern",
"vanessa",
"vanguard",
"vangueria",
"vanilla",
"vanillin",
"vanir",
"vanisher",
"vanishing",
"vanity",
"vanquisher",
"vantage",
"vanuatu",
"vanzetti",
"vapidity",
"vapidness",
"vapor",
"vaporing",
"vaporisation",
"vaporiser",
"vaporization",
"vaporizer",
"vaporousness",
"vapors",
"vapour",
"vapourousness",
"vapours",
"vaquero",
"vaquita",
"vara",
"varan",
"varanidae",
"varanus",
"vardenafil",
"varese",
"vargas",
"variability",
"variable",
"variableness",
"variance",
"variant",
"variate",
"variation",
"varicella",
"varicocele",
"varicosis",
"varicosity",
"variedness",
"variegation",
"varietal",
"variety",
"variola",
"variolation",
"variolization",
"variometer",
"variorum",
"varix",
"varlet",
"varment",
"varmint",
"varna",
"varnish",
"varnisher",
"varro",
"varsity",
"varuna",
"varus",
"vasarely",
"vasari",
"vascularisation",
"vascularity",
"vascularization",
"vasculitis",
"vase",
"vasectomy",
"vaseline",
"vasoconstrictor",
"vasodilation",
"vasodilative",
"vasodilator",
"vasomax",
"vasopressin",
"vasopressor",
"vasosection",
"vasotec",
"vasotomy",
"vasovasostomy",
"vasovesiculitis",
"vassal",
"vassalage",
"vastness",
"vatican",
"vaticination",
"vaticinator",
"vaudeville",
"vaudevillian",
"vaudois",
"vaughan",
"vault",
"vaulter",
"vaulting",
"vaunt",
"vaunter",
"vaux",
"vayu",
"veadar",
"veal",
"veau",
"veblen",
"vector",
"veda",
"vedalia",
"vedanga",
"vedanta",
"vedism",
"vedist",
"veering",
"veery",
"vega",
"vegan",
"vegetable",
"vegetarian",
"vegetarianism",
"vegetation",
"veggie",
"vehemence",
"vehicle",
"veil",
"veiling",
"vein",
"vela",
"velar",
"velazquez",
"velban",
"velcro",
"veld",
"veldt",
"velleity",
"vellication",
"vellum",
"velocipede",
"velociraptor",
"velocity",
"velodrome",
"velour",
"velours",
"veloute",
"velum",
"velveeta",
"velvet",
"velveteen",
"velvetleaf",
"velvetweed",
"vena",
"venality",
"venation",
"vendee",
"vendemiaire",
"vender",
"vendetta",
"vending",
"vendition",
"vendor",
"vendue",
"veneer",
"veneering",
"venerability",
"venerableness",
"veneration",
"venerator",
"veneridae",
"venesection",
"venetia",
"venetian",
"veneto",
"venezia",
"venezuela",
"venezuelan",
"vengeance",
"vengefulness",
"venice",
"venipuncture",
"venire",
"venison",
"venn",
"venogram",
"venography",
"venom",
"vent",
"ventail",
"venter",
"venthole",
"ventilation",
"ventilator",
"venting",
"ventner",
"ventolin",
"ventose",
"ventricle",
"ventriculus",
"ventriloquism",
"ventriloquist",
"ventriloquy",
"venture",
"venturer",
"venturesomeness",
"venturi",
"venue",
"venula",
"venule",
"venus",
"venushair",
"veps",
"vepse",
"vepsian",
"veracity",
"veracruz",
"veranda",
"verandah",
"verapamil",
"veratrum",
"verb",
"verbalisation",
"verbaliser",
"verbalism",
"verbalization",
"verbalizer",
"verbascum",
"verbena",
"verbenaceae",
"verbesina",
"verbiage",
"verbolatry",
"verboseness",
"verbosity",
"verdancy",
"verdandi",
"verdi",
"verdicchio",
"verdict",
"verdigris",
"verdin",
"verdolagas",
"verdun",
"verdure",
"verge",
"verger",
"vergil",
"verification",
"verifier",
"verisimilitude",
"verity",
"verlaine",
"vermeer",
"vermicelli",
"vermicide",
"vermiculation",
"vermiculite",
"vermifuge",
"vermilion",
"vermin",
"vermis",
"vermont",
"vermonter",
"vermouth",
"vernacular",
"vernation",
"verne",
"verner",
"vernier",
"vernix",
"vernonia",
"verona",
"veronal",
"veronese",
"veronica",
"verpa",
"verrazano",
"verrazzano",
"verruca",
"versace",
"versailles",
"versant",
"versatility",
"verse",
"versed",
"versicle",
"versification",
"versifier",
"version",
"verso",
"verst",
"vertebra",
"vertebrata",
"vertebrate",
"vertex",
"verthandi",
"vertical",
"verticality",
"verticalness",
"verticil",
"verticilliosis",
"verticillium",
"vertigo",
"vertu",
"vervain",
"verve",
"vervet",
"verwoerd",
"vesalius",
"vesey",
"vesica",
"vesicant",
"vesicaria",
"vesication",
"vesicatory",
"vesicle",
"vesicopapule",
"vesiculation",
"vesiculitis",
"vesiculovirus",
"vespa",
"vespasian",
"vesper",
"vespers",
"vespertilio",
"vespertilionid",
"vespid",
"vespidae",
"vespucci",
"vespula",
"vessel",
"vest",
"vesta",
"vestal",
"vestibule",
"vestige",
"vestiture",
"vestment",
"vestris",
"vestry",
"vestryman",
"vestrywoman",
"vesture",
"vesuvian",
"vesuvianite",
"vesuvius",
"vetch",
"vetchling",
"vetchworm",
"veteran",
"veterinarian",
"veterinary",
"vetluga",
"veto",
"vexation",
"vexer",
"viability",
"viaduct",
"viagra",
"vial",
"viand",
"viands",
"viatication",
"viaticus",
"vibe",
"vibes",
"vibist",
"viborg",
"vibraharp",
"vibramycin",
"vibrancy",
"vibraphone",
"vibraphonist",
"vibration",
"vibrato",
"vibrator",
"vibrio",
"vibrion",
"vibrissa",
"viburnum",
"vicar",
"vicarage",
"vicariate",
"vicarship",
"vice",
"vicegerent",
"vicereine",
"viceroy",
"viceroyalty",
"viceroyship",
"vichy",
"vichyssoise",
"vicia",
"vicinity",
"viciousness",
"vicissitude",
"vicksburg",
"victim",
"victimisation",
"victimiser",
"victimization",
"victimizer",
"victor",
"victoria",
"victorian",
"victoriana",
"victory",
"victrola",
"victual",
"victualer",
"victualler",
"victuals",
"vicugna",
"vicuna",
"vidal",
"vidalia",
"vidar",
"video",
"videocassette",
"videodisc",
"videodisk",
"videotape",
"vidua",
"vienna",
"vienne",
"vientiane",
"vieques",
"vietnam",
"vietnamese",
"view",
"viewer",
"viewers",
"viewfinder",
"viewgraph",
"viewing",
"viewpoint",
"vigil",
"vigilance",
"vigilante",
"vigilantism",
"vigna",
"vignette",
"vigor",
"vigorish",
"vigour",
"viii",
"viking",
"vila",
"vileness",
"vilification",
"vilifier",
"villa",
"village",
"villager",
"villahermosa",
"villain",
"villainage",
"villainess",
"villainousness",
"villainy",
"villard",
"villein",
"villeinage",
"villoma",
"villon",
"villus",
"vilna",
"vilnius",
"vilno",
"viminaria",
"vinaigrette",
"vinblastine",
"vinca",
"vincetoxicum",
"vincristine",
"vindication",
"vindicator",
"vindictiveness",
"vine",
"vinegar",
"vinegariness",
"vinegarishness",
"vinegarroon",
"vinegarweed",
"vinery",
"vineyard",
"viniculture",
"vinifera",
"vinification",
"vino",
"vinogradoff",
"vinson",
"vintage",
"vintager",
"vintner",
"vinyl",
"vinylbenzene",
"vinylite",
"viocin",
"viol",
"viola",
"violaceae",
"violation",
"violator",
"violence",
"violet",
"violin",
"violinist",
"violist",
"violoncellist",
"violoncello",
"viomycin",
"viosterol",
"vioxx",
"viper",
"vipera",
"viperidae",
"viracept",
"viraemia",
"virago",
"viramune",
"virazole",
"virchow",
"viremia",
"vireo",
"vireonidae",
"virga",
"virgil",
"virgilia",
"virgin",
"virginal",
"virginia",
"virginian",
"virginity",
"virgo",
"virgule",
"viricide",
"viridity",
"virilisation",
"virilism",
"virility",
"virilization",
"virino",
"virion",
"viroid",
"virologist",
"virology",
"virtu",
"virtue",
"virtuosity",
"virtuoso",
"virtuousness",
"virucide",
"virulence",
"virulency",
"virus",
"virusoid",
"visa",
"visage",
"visayan",
"viscaceae",
"viscacha",
"viscera",
"viscidity",
"viscidness",
"viscometer",
"viscometry",
"visconti",
"viscose",
"viscosimeter",
"viscosimetry",
"viscosity",
"viscount",
"viscountcy",
"viscountess",
"viscounty",
"viscousness",
"viscum",
"viscus",
"vise",
"vishnu",
"vishnuism",
"visibility",
"visibleness",
"visigoth",
"vision",
"visionary",
"visit",
"visitant",
"visitation",
"visiting",
"visitor",
"visken",
"visor",
"vista",
"vistaril",
"vistula",
"visualisation",
"visualiser",
"visualization",
"visualizer",
"vitaceae",
"vitalisation",
"vitaliser",
"vitalism",
"vitalist",
"vitality",
"vitalization",
"vitalizer",
"vitalness",
"vitals",
"vitamin",
"vitellus",
"vithar",
"vitharr",
"vitiation",
"viticulture",
"viticulturist",
"vitidaceae",
"vitiligo",
"vitis",
"vitrectomy",
"vitrification",
"vitrine",
"vitriol",
"vittaria",
"vittariaceae",
"vituperation",
"vitus",
"viva",
"vivacity",
"vivaldi",
"vivarium",
"viverra",
"viverricula",
"viverridae",
"viverrinae",
"viverrine",
"vividness",
"vivification",
"vivisection",
"vivisectionist",
"vixen",
"viyella",
"vizcaino",
"vizier",
"viziership",
"vizor",
"vizsla",
"vladivostok",
"vlaminck",
"vldl",
"vocable",
"vocabulary",
"vocal",
"vocalisation",
"vocaliser",
"vocalism",
"vocalist",
"vocalization",
"vocalizer",
"vocalizing",
"vocation",
"vocative",
"vociferation",
"vociferator",
"vodka",
"vodoun",
"vogue",
"vogul",
"voice",
"voicelessness",
"voicemail",
"voiceprint",
"voicer",
"voicing",
"void",
"voidance",
"voider",
"voiding",
"voile",
"volaille",
"volans",
"volapuk",
"volary",
"volatile",
"volatility",
"volcanism",
"volcano",
"volcanology",
"vole",
"volga",
"volgaic",
"volgograd",
"volition",
"volkhov",
"volley",
"volleyball",
"volt",
"volta",
"voltage",
"voltaic",
"voltaire",
"voltaren",
"voltmeter",
"volubility",
"volume",
"volumeter",
"voluminosity",
"voluminousness",
"volund",
"voluntary",
"volunteer",
"voluptuary",
"voluptuousness",
"volute",
"volution",
"volva",
"volvaria",
"volvariaceae",
"volvariella",
"volvelle",
"volvocaceae",
"volvocales",
"volvox",
"volvulus",
"vombatidae",
"vomer",
"vomit",
"vomiter",
"vomiting",
"vomitive",
"vomitory",
"vomitus",
"vonnegut",
"voodoo",
"voodooism",
"voraciousness",
"voracity",
"vortex",
"vorticella",
"votary",
"vote",
"voter",
"voting",
"votyak",
"vouchee",
"voucher",
"vouge",
"voussoir",
"vouvray",
"vowel",
"vower",
"voyage",
"voyager",
"voyeur",
"voyeurism",
"voznesenski",
"vroom",
"vuillard",
"vulcan",
"vulcanisation",
"vulcaniser",
"vulcanite",
"vulcanization",
"vulcanizer",
"vulcanology",
"vulgarian",
"vulgarisation",
"vulgariser",
"vulgarism",
"vulgarity",
"vulgarization",
"vulgarizer",
"vulgate",
"vulnerability",
"vulpecula",
"vulpes",
"vultur",
"vulture",
"vulva",
"vulvectomy",
"vulvitis",
"vulvovaginitis",
"wabash",
"wacko",
"waco",
"wadding",
"waddle",
"waddler",
"wade",
"wader",
"waders",
"wadi",
"wading",
"wads",
"wafer",
"waffle",
"waffler",
"waft",
"wafture",
"wage",
"wager",
"wagerer",
"wages",
"waggery",
"waggishness",
"waggle",
"waggon",
"waggoner",
"waggonwright",
"wagner",
"wagnerian",
"wagon",
"wagoner",
"wagonwright",
"wagram",
"wagtail",
"wahabi",
"wahabism",
"wahhabi",
"wahhabism",
"wahoo",
"wahunsonacock",
"wahvey",
"waif",
"waikiki",
"wail",
"wailer",
"wailing",
"wain",
"wainscot",
"wainscoting",
"wainscotting",
"wainwright",
"waist",
"waistband",
"waistcloth",
"waistcoat",
"waistline",
"wait",
"waite",
"waiter",
"waiting",
"waitress",
"waiver",
"wajda",
"wakashan",
"wake",
"wakeboard",
"wakefulness",
"wakening",
"waker",
"waking",
"walapai",
"walbiri",
"waldenses",
"waldheim",
"waldmeister",
"wale",
"wales",
"walesa",
"walhalla",
"walk",
"walkabout",
"walkaway",
"walker",
"walking",
"walkingstick",
"walkman",
"walkout",
"walkover",
"walkway",
"wall",
"wallaby",
"wallace",
"wallah",
"wallboard",
"wallenstein",
"waller",
"wallet",
"walleye",
"wallflower",
"walloon",
"walloons",
"wallop",
"walloper",
"walloping",
"wallow",
"wallpaper",
"wallpaperer",
"wally",
"walnut",
"walpole",
"walrus",
"walter",
"walton",
"waltz",
"waltzer",
"wampanoag",
"wampee",
"wampum",
"wampumpeag",
"wanamaker",
"wand",
"wandala",
"wanderer",
"wandering",
"wanderlust",
"wandflower",
"wane",
"wangle",
"wangler",
"wangling",
"waning",
"wank",
"wanker",
"wannabe",
"wannabee",
"wanness",
"want",
"wanter",
"wanton",
"wantonness",
"wapiti",
"waratah",
"warble",
"warbler",
"warburg",
"ward",
"warden",
"wardenship",
"warder",
"wardership",
"wardress",
"wardrobe",
"wardroom",
"ware",
"warehouse",
"warehouseman",
"warehouser",
"warehousing",
"warfare",
"warfarin",
"warhead",
"warhol",
"warhorse",
"wariness",
"warji",
"warlock",
"warlord",
"warlpiri",
"warmer",
"warmheartedness",
"warming",
"warmness",
"warmonger",
"warmongering",
"warmth",
"warner",
"warning",
"warp",
"warpath",
"warping",
"warplane",
"warragal",
"warrant",
"warrantee",
"warranter",
"warrantor",
"warranty",
"warren",
"warrener",
"warrigal",
"warrior",
"warsaw",
"warship",
"warszawa",
"wart",
"warthog",
"wartime",
"wartweed",
"wartwort",
"warwick",
"wasabi",
"wash",
"washables",
"washbasin",
"washboard",
"washbowl",
"washcloth",
"washday",
"washer",
"washerman",
"washerwoman",
"washhouse",
"washing",
"washington",
"washingtonian",
"washout",
"washrag",
"washroom",
"washstand",
"washtub",
"washup",
"washwoman",
"wasp",
"wassail",
"wassailer",
"wassermann",
"wastage",
"waste",
"wastebasket",
"wastebin",
"wastefulness",
"wasteland",
"waster",
"wastewater",
"wasteweir",
"wasteyard",
"wasting",
"wastrel",
"watch",
"watchband",
"watchdog",
"watcher",
"watchfulness",
"watching",
"watchmaker",
"watchman",
"watchstrap",
"watchtower",
"watchword",
"water",
"waterbird",
"waterbuck",
"waterbury",
"watercannon",
"watercolor",
"watercolorist",
"watercolour",
"watercolourist",
"watercourse",
"watercraft",
"watercress",
"waterdog",
"waterer",
"waterfall",
"waterfinder",
"waterford",
"waterfowl",
"waterfront",
"watergate",
"wateriness",
"watering",
"waterleaf",
"waterlessness",
"waterline",
"waterloo",
"waterman",
"watermark",
"watermeal",
"watermelon",
"waterpower",
"waterproof",
"waterproofing",
"waters",
"waterscape",
"watershed",
"waterside",
"waterskin",
"waterspout",
"watertown",
"waterway",
"waterweed",
"waterwheel",
"waterworks",
"wats",
"watson",
"watt",
"wattage",
"watteau",
"wattle",
"wattmeter",
"watts",
"watusi",
"watutsi",
"waugh",
"wausau",
"wave",
"waveband",
"waveform",
"wavefront",
"waveguide",
"wavelength",
"wavelet",
"wavell",
"waver",
"waverer",
"wavering",
"waviness",
"waving",
"waxberry",
"waxflower",
"waxiness",
"waxing",
"waxmallow",
"waxwing",
"waxwork",
"waxycap",
"waybill",
"wayfarer",
"wayfaring",
"wayland",
"wayne",
"ways",
"wayside",
"weakener",
"weakening",
"weakfish",
"weakling",
"weakness",
"weal",
"weald",
"wealth",
"wealthiness",
"weaning",
"weapon",
"weaponry",
"wear",
"wearable",
"wearer",
"weariness",
"wearing",
"weasel",
"weather",
"weatherboard",
"weatherboarding",
"weathercock",
"weatherglass",
"weatherliness",
"weatherman",
"weatherstrip",
"weathervane",
"weave",
"weaver",
"weaverbird",
"weaving",
"webb",
"webbing",
"webcam",
"weber",
"webfoot",
"webmaster",
"webpage",
"website",
"webster",
"webworm",
"wedding",
"wedge",
"wedgie",
"wedgwood",
"wedlock",
"wednesday",
"weed",
"weeder",
"weedkiller",
"weeds",
"week",
"weekday",
"weekend",
"weekender",
"weekly",
"weeknight",
"weeness",
"weenie",
"weeper",
"weepiness",
"weeping",
"weevil",
"weewee",
"weft",
"wegener",
"weigela",
"weighbridge",
"weigher",
"weighing",
"weight",
"weightiness",
"weighting",
"weightlessness",
"weightlift",
"weightlifter",
"weightlifting",
"weil",
"weill",
"weimar",
"weimaraner",
"weinberg",
"weir",
"weird",
"weirdie",
"weirdness",
"weirdo",
"weirdy",
"weisenheimer",
"weismann",
"weissbier",
"weisshorn",
"weizenbier",
"weizenbock",
"weizmann",
"weka",
"welcher",
"welcome",
"welcomer",
"weld",
"welder",
"welding",
"weldment",
"welfare",
"welkin",
"well",
"wellbeing",
"wellerism",
"welles",
"wellhead",
"wellington",
"wellness",
"wellpoint",
"wells",
"wellspring",
"welsh",
"welsher",
"welshman",
"welt",
"weltanschauung",
"welter",
"welterweight",
"weltschmerz",
"welty",
"welwitschia",
"welwitschiaceae",
"wembley",
"wench",
"wencher",
"werewolf",
"werfel",
"wernicke",
"weser",
"wesley",
"wesleyan",
"wesleyanism",
"wesleyism",
"wessex",
"west",
"wester",
"westerly",
"western",
"westerner",
"westernisation",
"westernization",
"westinghouse",
"westminster",
"weston",
"westward",
"wetback",
"wether",
"wetland",
"wetness",
"wetnurse",
"wetter",
"wetting",
"whack",
"whacker",
"whacking",
"whacko",
"whale",
"whaleboat",
"whalebone",
"whaler",
"whalesucker",
"whammy",
"whang",
"wharf",
"wharfage",
"wharton",
"whatchamacallit",
"whatchamacallum",
"whatnot",
"whatsis",
"wheal",
"wheat",
"wheatear",
"wheatfield",
"wheatflake",
"wheatgrass",
"wheatley",
"wheatstone",
"wheatworm",
"wheedler",
"wheedling",
"wheel",
"wheelbarrow",
"wheelbase",
"wheelchair",
"wheeler",
"wheelhouse",
"wheeling",
"wheelwork",
"wheelwright",
"wheeze",
"wheeziness",
"whelk",
"whelp",
"whereabouts",
"wherefore",
"wherewithal",
"wherry",
"whetstone",
"whey",
"whicker",
"whidah",
"whiff",
"whiffer",
"whiffletree",
"whig",
"while",
"whim",
"whimper",
"whimsey",
"whimsicality",
"whimsy",
"whin",
"whinberry",
"whinchat",
"whine",
"whiner",
"whinny",
"whinstone",
"whip",
"whipcord",
"whiplash",
"whipper",
"whippersnapper",
"whippet",
"whipping",
"whippletree",
"whippoorwill",
"whipsaw",
"whipsnake",
"whipstitch",
"whipstitching",
"whiptail",
"whir",
"whirl",
"whirlaway",
"whirler",
"whirligig",
"whirling",
"whirlpool",
"whirlwind",
"whirlybird",
"whirr",
"whirring",
"whisk",
"whisker",
"whiskers",
"whiskey",
"whisky",
"whisper",
"whisperer",
"whispering",
"whist",
"whistle",
"whistleblower",
"whistler",
"whistling",
"whit",
"white",
"whitebait",
"whitecap",
"whitecup",
"whiteface",
"whitefish",
"whitefly",
"whitehall",
"whitehead",
"whitehorse",
"whitelash",
"whitener",
"whiteness",
"whitening",
"whiteout",
"whitetail",
"whitethorn",
"whitethroat",
"whitewash",
"whitewater",
"whitewood",
"whitey",
"whiting",
"whitlavia",
"whitlow",
"whitlowwort",
"whitman",
"whitmonday",
"whitney",
"whitsun",
"whitsunday",
"whitsuntide",
"whittier",
"whittle",
"whittler",
"whitweek",
"whiz",
"whizbang",
"whizz",
"whizzbang",
"whodunit",
"whole",
"wholeness",
"wholesale",
"wholesaler",
"wholesomeness",
"whoop",
"whoopee",
"whooper",
"whoosh",
"whopper",
"whore",
"whoredom",
"whorehouse",
"whoremaster",
"whoremonger",
"whoreson",
"whorl",
"whorlywort",
"whortleberry",
"whydah",
"wicca",
"wiccan",
"wichita",
"wick",
"wickedness",
"wicker",
"wickerwork",
"wicket",
"wickiup",
"wickliffe",
"wickup",
"wiclif",
"wicopy",
"wideness",
"widening",
"widgeon",
"widget",
"widow",
"widower",
"widowhood",
"widowman",
"width",
"wieland",
"wiener",
"wienerwurst",
"wiesbaden",
"wiesel",
"wiesenboden",
"wiesenthal",
"wife",
"wiffle",
"wifi",
"wigeon",
"wigging",
"wiggle",
"wiggler",
"wiggliness",
"wight",
"wigmaker",
"wigner",
"wigwam",
"wikiup",
"wild",
"wildcat",
"wildcatter",
"wilde",
"wildebeest",
"wilder",
"wilderness",
"wildfire",
"wildflower",
"wildfowl",
"wilding",
"wildlife",
"wildness",
"wile",
"wilfulness",
"wiliness",
"wilkes",
"wilkins",
"wilkinson",
"will",
"willamette",
"willard",
"willebrand",
"willet",
"willfulness",
"williams",
"williamstown",
"willies",
"willing",
"willingness",
"willis",
"willow",
"willowherb",
"willowware",
"willpower",
"wilmington",
"wilmut",
"wilno",
"wilson",
"wilt",
"wilting",
"wilton",
"wimble",
"wimbledon",
"wimp",
"wimple",
"wince",
"wincey",
"winceyette",
"winch",
"winchester",
"winckelmann",
"wind",
"windage",
"windaus",
"windbag",
"windbreak",
"windbreaker",
"windburn",
"windcheater",
"winder",
"windfall",
"windflower",
"windhoek",
"windiness",
"winding",
"windjammer",
"windlass",
"windlessness",
"windmill",
"window",
"windowpane",
"windows",
"windowsill",
"windpipe",
"windscreen",
"windshield",
"windsock",
"windsor",
"windstorm",
"windtalker",
"windup",
"windward",
"wine",
"wineberry",
"wineglass",
"winemaker",
"winemaking",
"winepress",
"winery",
"winesap",
"wineskin",
"winfred",
"wing",
"wingback",
"winger",
"wingman",
"wings",
"wingspan",
"wingspread",
"wingstem",
"wink",
"winker",
"winking",
"winkle",
"winnebago",
"winner",
"winning",
"winnings",
"winnipeg",
"winnow",
"winnowing",
"wino",
"winslow",
"winsomeness",
"winter",
"wintera",
"winteraceae",
"winterberry",
"wintergreen",
"wintertime",
"wintun",
"wipe",
"wipeout",
"wiper",
"wire",
"wirehair",
"wireless",
"wireman",
"wirer",
"wiretap",
"wiretapper",
"wirework",
"wireworm",
"wiriness",
"wiring",
"wisconsin",
"wisconsinite",
"wisdom",
"wise",
"wiseacre",
"wisecrack",
"wiseness",
"wisenheimer",
"wisent",
"wish",
"wishbone",
"wishfulness",
"wishing",
"wisp",
"wistaria",
"wister",
"wisteria",
"wistfulness",
"witch",
"witchcraft",
"witchery",
"witchgrass",
"witching",
"withdrawal",
"withdrawer",
"withdrawnness",
"withe",
"withering",
"withers",
"witherspoon",
"withholder",
"withholding",
"withstander",
"withy",
"witloof",
"witness",
"witnesser",
"wits",
"wittgenstein",
"witticism",
"wittiness",
"wittol",
"witwatersrand",
"wivern",
"wizard",
"wizardry",
"wlan",
"woad",
"woadwaxen",
"wobble",
"wobbler",
"wobbly",
"wodan",
"wodehouse",
"woden",
"woefulness",
"wold",
"wolf",
"wolfbane",
"wolfe",
"wolff",
"wolffia",
"wolffiella",
"wolffish",
"wolfhound",
"wolfman",
"wolfram",
"wolframite",
"wolfsbane",
"wollaston",
"wollastonite",
"wollstonecraft",
"wolof",
"wolverine",
"woman",
"womanhood",
"womaniser",
"womanishness",
"womanizer",
"womankind",
"womanlike",
"womanliness",
"womb",
"wombat",
"wonder",
"wonderberry",
"wonderer",
"wonderfulness",
"wonderland",
"wonderment",
"wonk",
"wont",
"wonton",
"wood",
"woodbine",
"woodborer",
"woodbury",
"woodcarver",
"woodcarving",
"woodchuck",
"woodcock",
"woodcraft",
"woodcreeper",
"woodcut",
"woodcutter",
"woodenness",
"woodenware",
"woodfern",
"woodgrain",
"woodgraining",
"woodhewer",
"woodhull",
"woodiness",
"woodland",
"woodlet",
"woodlouse",
"woodman",
"woodpecker",
"woodpile",
"woodruff",
"woods",
"woodscrew",
"woodshed",
"woodsia",
"woodsiness",
"woodsman",
"woodward",
"woodwardia",
"woodwaxen",
"woodwind",
"woodwork",
"woodworker",
"woodworking",
"woodworm",
"wooer",
"woof",
"woofer",
"wooing",
"wool",
"woolen",
"woolf",
"woolgatherer",
"woolgathering",
"woollcott",
"woollen",
"woolley",
"woolsorter",
"woolworth",
"worcester",
"worcestershire",
"word",
"wordbook",
"wordfinder",
"wordiness",
"wording",
"wordmonger",
"wordnet",
"wordplay",
"words",
"wordsmith",
"wordsworth",
"work",
"workaholic",
"workaholism",
"workbag",
"workbasket",
"workbench",
"workboard",
"workbook",
"workbox",
"workday",
"worker",
"workfellow",
"workflow",
"workforce",
"workhorse",
"workhouse",
"working",
"workingman",
"workings",
"workload",
"workman",
"workmanship",
"workmate",
"workout",
"workpiece",
"workplace",
"workroom",
"works",
"worksheet",
"workshop",
"workspace",
"workstation",
"worktable",
"workwear",
"workweek",
"world",
"worldliness",
"worldling",
"worm",
"wormcast",
"wormhole",
"wormseed",
"wormwood",
"worrier",
"worriment",
"worry",
"worrying",
"worrywart",
"worse",
"worsening",
"worship",
"worshiper",
"worshipper",
"worst",
"worsted",
"wort",
"worth",
"worthiness",
"worthlessness",
"worthwhileness",
"worthy",
"wotan",
"wouk",
"wound",
"wounded",
"wounding",
"wrack",
"wraith",
"wrangle",
"wrangler",
"wrangling",
"wrap",
"wraparound",
"wrapper",
"wrapping",
"wrasse",
"wrath",
"wreath",
"wreck",
"wreckage",
"wrecker",
"wreckfish",
"wrecking",
"wren",
"wrench",
"wrester",
"wrestle",
"wrestler",
"wrestling",
"wretch",
"wretchedness",
"wrick",
"wriggle",
"wriggler",
"wright",
"wring",
"wringer",
"wrinkle",
"wrist",
"wristband",
"wristlet",
"wristwatch",
"writ",
"writer",
"writing",
"writings",
"wroclaw",
"wrong",
"wrongdoer",
"wrongdoing",
"wrongfulness",
"wrongness",
"wrymouth",
"wryneck",
"wuerzburg",
"wuhan",
"wulfenite",
"wulfila",
"wurlitzer",
"wurtzite",
"wurzburg",
"wuss",
"wyat",
"wyatt",
"wycherley",
"wyclif",
"wycliffe",
"wyeth",
"wykeham",
"wykehamist",
"wyler",
"wylie",
"wynette",
"wynfrith",
"wynnea",
"wyoming",
"wyomingite",
"wyrd",
"wyszynski",
"wytensin",
"wyvern",
"xanax",
"xanthate",
"xanthelasma",
"xanthemia",
"xanthine",
"xanthium",
"xanthoma",
"xanthomatosis",
"xanthomonad",
"xanthomonas",
"xanthophyceae",
"xanthophyl",
"xanthophyll",
"xanthopsia",
"xanthorroea",
"xanthosis",
"xanthosoma",
"xantusiidae",
"xavier",
"xenarthra",
"xenicidae",
"xenicus",
"xenogenesis",
"xenograft",
"xenolith",
"xenon",
"xenophanes",
"xenophobia",
"xenophon",
"xenopodidae",
"xenopus",
"xenorhyncus",
"xenosauridae",
"xenosaurus",
"xenotime",
"xenotransplant",
"xeranthemum",
"xerobates",
"xeroderma",
"xerodermia",
"xerography",
"xeroma",
"xerophile",
"xerophthalmia",
"xerophthalmus",
"xerophyllum",
"xerophyte",
"xeroradiography",
"xerostomia",
"xerotes",
"xerox",
"xhosa",
"xian",
"xiii",
"xinjiang",
"xiphias",
"xiphiidae",
"xiphosura",
"xizang",
"xmas",
"xvii",
"xviii",
"xxii",
"xxiii",
"xxiv",
"xxix",
"xxvi",
"xxvii",
"xxviii",
"xylaria",
"xylariaceae",
"xylem",
"xylene",
"xylocaine",
"xylocopa",
"xylol",
"xylomelum",
"xylophone",
"xylophonist",
"xylopia",
"xylose",
"xylosma",
"xyphophorus",
"xyridaceae",
"xyridales",
"xyris",
"yacca",
"yacht",
"yachting",
"yachtsman",
"yachtswoman",
"yack",
"yafo",
"yagi",
"yahi",
"yahoo",
"yahve",
"yahveh",
"yahwe",
"yahweh",
"yakima",
"yakut",
"yakuza",
"yale",
"yalta",
"yaltopya",
"yalu",
"yama",
"yamaltu",
"yamamoto",
"yamani",
"yamoussukro",
"yana",
"yanan",
"yang",
"yangon",
"yangtze",
"yank",
"yankee",
"yanker",
"yanquapin",
"yaounde",
"yard",
"yardage",
"yardarm",
"yardbird",
"yarder",
"yardgrass",
"yardie",
"yardman",
"yardmaster",
"yardstick",
"yarmelke",
"yarmulka",
"yarmulke",
"yarn",
"yarrow",
"yashmac",
"yashmak",
"yastrzemski",
"yataghan",
"yatobyo",
"yautia",
"yavapai",
"yawl",
"yawn",
"yawner",
"yawning",
"yaws",
"yazoo",
"ybit",
"year",
"yearbook",
"yearling",
"yearly",
"yearner",
"yearning",
"years",
"yeast",
"yeats",
"yeddo",
"yedo",
"yekaterinoslav",
"yell",
"yeller",
"yelling",
"yellow",
"yellowbird",
"yellowcake",
"yellowfin",
"yellowhammer",
"yellowknife",
"yellowlegs",
"yellowness",
"yellowstone",
"yellowtail",
"yellowthroat",
"yellowwood",
"yelp",
"yelping",
"yemen",
"yemeni",
"yenisei",
"yeniseian",
"yenisey",
"yenta",
"yeoman",
"yeomanry",
"yerevan",
"yerkes",
"yersin",
"yerupaja",
"yeshiva",
"yeshivah",
"yesterday",
"yesteryear",
"yeti",
"yevtushenko",
"yezo",
"ygdrasil",
"yggdrasil",
"yhvh",
"yhwh",
"yibit",
"yiddish",
"yield",
"yielder",
"yielding",
"yips",
"yisrael",
"ylem",
"ymir",
"yobbo",
"yobibit",
"yobibyte",
"yobo",
"yodel",
"yodeling",
"yodeller",
"yodh",
"yoga",
"yogacara",
"yoghourt",
"yoghurt",
"yogi",
"yogurt",
"yoke",
"yokel",
"yokohama",
"yokuts",
"yolk",
"yore",
"york",
"yorkshire",
"yorktown",
"yoruba",
"yosemite",
"yottabit",
"yottabyte",
"young",
"youngness",
"youngster",
"youngstown",
"younker",
"youth",
"youthfulness",
"yowl",
"ypres",
"yquem",
"ytterbite",
"ytterbium",
"yttrium",
"yuan",
"yucatan",
"yucatec",
"yucateco",
"yucca",
"yugoslav",
"yugoslavia",
"yugoslavian",
"yukawa",
"yukon",
"yule",
"yuletide",
"yuma",
"yuman",
"yunnan",
"yuppie",
"yurt",
"zaar",
"zabaglione",
"zabrze",
"zacharias",
"zaglossus",
"zagreb",
"zaharias",
"zaire",
"zairean",
"zairese",
"zakat",
"zalcitabine",
"zalophus",
"zama",
"zaman",
"zamang",
"zambezi",
"zambia",
"zambian",
"zamboni",
"zamboorak",
"zamburak",
"zamburek",
"zamia",
"zamiaceae",
"zangwill",
"zannichellia",
"zantac",
"zantedeschia",
"zanthoxylum",
"zanuck",
"zany",
"zanzibar",
"zapata",
"zapodidae",
"zapotec",
"zapotecan",
"zapper",
"zapus",
"zaragoza",
"zarathustra",
"zarf",
"zaria",
"zarontin",
"zarpanit",
"zarqa",
"zayin",
"zbit",
"zeal",
"zealand",
"zealander",
"zealot",
"zealotry",
"zeaxanthin",
"zebibit",
"zebibyte",
"zebra",
"zebrawood",
"zebu",
"zechariah",
"zeeman",
"zeidae",
"zeitgeist",
"zenaidura",
"zend",
"zenith",
"zeno",
"zeolite",
"zeomorphi",
"zephaniah",
"zephyr",
"zeppelin",
"zeppo",
"zero",
"zest",
"zestfulness",
"zestril",
"zeta",
"zetland",
"zettabit",
"zettabyte",
"zeugma",
"zeus",
"zhou",
"zhuang",
"zhukov",
"zibit",
"zidovudine",
"ziegfeld",
"ziegler",
"zigadene",
"zigadenus",
"ziggurat",
"zigzag",
"zikkurat",
"zikurat",
"zilch",
"zill",
"zillion",
"zimbabwe",
"zimbabwean",
"zimbalist",
"zimmer",
"zinacef",
"zinc",
"zinfandel",
"zing",
"zinger",
"zingiber",
"zingiberaceae",
"zinjanthropus",
"zinkenite",
"zinnemann",
"zinnia",
"zinnwaldite",
"zinsser",
"zinzendorf",
"zion",
"zionism",
"zionist",
"ziphiidae",
"zipper",
"zippo",
"zirbanit",
"zircon",
"zirconia",
"zirconium",
"zither",
"zithern",
"zithromax",
"ziti",
"zizania",
"ziziphus",
"zizz",
"zloty",
"zoanthropy",
"zoarces",
"zoarcidae",
"zocor",
"zodiac",
"zoisia",
"zola",
"zoloft",
"zomba",
"zombi",
"zombie",
"zona",
"zone",
"zoning",
"zonotrichia",
"zonula",
"zonule",
"zooerastia",
"zooerasty",
"zooflagellate",
"zooid",
"zoolatry",
"zoologist",
"zoology",
"zoom",
"zoomastigina",
"zoomastigote",
"zoomorphism",
"zoonosis",
"zoophilia",
"zoophilism",
"zoophobia",
"zoophyte",
"zooplankton",
"zoopsia",
"zoospore",
"zootoxin",
"zori",
"zoril",
"zoroaster",
"zoroastrian",
"zoroastrianism",
"zoster",
"zostera",
"zosteraceae",
"zovirax",
"zoysia",
"zsigmondy",
"zubird",
"zucchini",
"zukerman",
"zulu",
"zumbooruck",
"zumbooruk",
"zuni",
"zurich",
"zurvan",
"zurvanism",
"zweig",
"zwieback",
"zwingli",
"zworykin",
"zydeco",
"zygnema",
"zygnemales",
"zygnemataceae",
"zygnematales",
"zygocactus",
"zygoma",
"zygomatic",
"zygomycetes",
"zygomycota",
"zygomycotina",
"zygophyllaceae",
"zygophyllum",
"zygoptera",
"zygospore",
"zygote",
"zygotene",
"zyloprim",
"zymase",
"zymogen",
"zymology",
"zymolysis",
"zymosis",
"zymurgy",
"zyrian",
} | nouns.go | 0.510496 | 0.467757 | nouns.go | starcoder |
package forGraphBLASGo
import "github.com/intel/forGoParallel/pipeline"
type matrixSelect[D, Ds any] struct {
op IndexUnaryOp[bool, D, Ds]
A *matrixReference[D]
value Ds
}
func newMatrixSelect[D, Ds any](op IndexUnaryOp[bool, D, Ds], A *matrixReference[D], value Ds) computeMatrixT[D] {
return matrixSelect[D, Ds]{op: op, A: A, value: value}
}
func (compute matrixSelect[D, Ds]) resize(newNRows, newNCols int) computeMatrixT[D] {
return newMatrixSelect[D, Ds](compute.op, compute.A.resize(newNRows, newNCols), compute.value)
}
func (compute matrixSelect[D, Ds]) computeElement(row, col int) (result D, ok bool) {
if A, Aok := compute.A.extractElement(row, col); Aok {
if compute.op(A, row, col, compute.value) {
return A, true
}
}
return
}
func (compute matrixSelect[D, Ds]) computePipeline() *pipeline.Pipeline[any] {
p := compute.A.getPipeline()
if p == nil {
return nil
}
p.Add(
pipeline.Par(pipeline.Receive(func(_ int, data any) any {
slice := data.(matrixSlice[D])
slice.filter(func(row, col int, value D) (newRow, newCol int, newValue D, ok bool) {
return row, col, value, compute.op(value, row, col, compute.value)
})
return slice
})),
)
return p
}
func (compute matrixSelect[D, Ds]) addRowPipeline(row int, p *pipeline.Pipeline[any]) {
p.Add(
pipeline.Par(pipeline.Receive(func(_ int, data any) any {
slice := data.(vectorSlice[D])
slice.filter(func(col int, value D) (newCol int, newValue D, ok bool) {
return col, value, compute.op(value, row, col, compute.value)
})
return slice
})),
)
}
func (compute matrixSelect[D, Ds]) computeRowPipeline(row int) *pipeline.Pipeline[any] {
p := compute.A.getRowPipeline(row)
if p == nil {
return nil
}
compute.addRowPipeline(row, p)
return p
}
func (compute matrixSelect[D, Ds]) addColPipeline(col int, p *pipeline.Pipeline[any]) {
p.Add(
pipeline.Par(pipeline.Receive(func(_ int, data any) any {
slice := data.(vectorSlice[D])
slice.filter(func(row int, value D) (newRow int, newValue D, ok bool) {
return row, value, compute.op(value, row, col, compute.value)
})
return slice
})),
)
}
func (compute matrixSelect[D, Ds]) computeColPipeline(col int) *pipeline.Pipeline[any] {
p := compute.A.getColPipeline(col)
if p == nil {
return nil
}
compute.addColPipeline(col, p)
return p
}
func (compute matrixSelect[D, Ds]) computeRowPipelines() []matrix1Pipeline {
ps := compute.A.getRowPipelines()
for _, p := range ps {
compute.addRowPipeline(p.index, p.p)
}
return ps
}
func (compute matrixSelect[D, Ds]) computeColPipelines() []matrix1Pipeline {
ps := compute.A.getColPipelines()
for _, p := range ps {
compute.addColPipeline(p.index, p.p)
}
return ps
}
type matrixSelectScalar[D, Ds any] struct {
op IndexUnaryOp[bool, D, Ds]
A *matrixReference[D]
value *scalarReference[Ds]
}
func newMatrixSelectScalar[D, Ds any](op IndexUnaryOp[bool, D, Ds], A *matrixReference[D], value *scalarReference[Ds]) computeMatrixT[D] {
return matrixSelectScalar[D, Ds]{op: op, A: A, value: value}
}
func (compute matrixSelectScalar[D, Ds]) resize(newNRows, newNCols int) computeMatrixT[D] {
return newMatrixSelectScalar[D, Ds](compute.op, compute.A.resize(newNRows, newNCols), compute.value)
}
func (compute matrixSelectScalar[D, Ds]) computeElement(row, col int) (result D, ok bool) {
if a, aok := compute.A.extractElement(row, col); aok {
if value, vok := compute.value.extractElement(); vok {
if compute.op(a, row, col, value) {
return a, true
}
} else {
panic(EmptyObject)
}
}
return
}
func (compute matrixSelectScalar[D, Ds]) computePipeline() *pipeline.Pipeline[any] {
p := compute.A.getPipeline()
if p == nil {
return nil
}
v, vok := compute.value.extractElement()
if !vok {
panic(EmptyObject)
}
p.Add(
pipeline.Par(pipeline.Receive(func(_ int, data any) any {
slice := data.(matrixSlice[D])
slice.filter(func(row, col int, value D) (newRow, newCol int, newValue D, ok bool) {
return row, col, value, compute.op(value, row, col, v)
})
return slice
})),
)
return p
}
func (compute matrixSelectScalar[D, Ds]) addRowPipeline(row int, p *pipeline.Pipeline[any], v Ds) {
p.Add(
pipeline.Par(pipeline.Receive(func(_ int, data any) any {
slice := data.(vectorSlice[D])
slice.filter(func(col int, value D) (newCol int, newValue D, ok bool) {
return col, value, compute.op(value, row, col, v)
})
return slice
})),
)
}
func (compute matrixSelectScalar[D, Ds]) computeRowPipeline(row int) *pipeline.Pipeline[any] {
p := compute.A.getRowPipeline(row)
if p == nil {
return nil
}
v, vok := compute.value.extractElement()
if !vok {
panic(EmptyObject)
}
compute.addRowPipeline(row, p, v)
return p
}
func (compute matrixSelectScalar[D, Ds]) addColPipeline(col int, p *pipeline.Pipeline[any], v Ds) {
p.Add(
pipeline.Par(pipeline.Receive(func(_ int, data any) any {
slice := data.(vectorSlice[D])
slice.filter(func(row int, value D) (newRow int, newValue D, ok bool) {
return row, value, compute.op(value, row, col, v)
})
return slice
})),
)
}
func (compute matrixSelectScalar[D, Ds]) computeColPipeline(col int) *pipeline.Pipeline[any] {
p := compute.A.getColPipeline(col)
if p == nil {
return nil
}
v, vok := compute.value.extractElement()
if !vok {
panic(EmptyObject)
}
compute.addColPipeline(col, p, v)
return p
}
func (compute matrixSelectScalar[D, Ds]) computeRowPipelines() []matrix1Pipeline {
v, vok := compute.value.extractElement()
if !vok {
panic(EmptyObject)
}
ps := compute.A.getRowPipelines()
for _, p := range ps {
compute.addRowPipeline(p.index, p.p, v)
}
return ps
}
func (compute matrixSelectScalar[D, Ds]) computeColPipelines() []matrix1Pipeline {
v, vok := compute.value.extractElement()
if !vok {
panic(EmptyObject)
}
ps := compute.A.getColPipelines()
for _, p := range ps {
compute.addColPipeline(p.index, p.p, v)
}
return ps
} | functional_Matrix_ComputedSelect.go | 0.663996 | 0.593167 | functional_Matrix_ComputedSelect.go | starcoder |
package orientation
import (
"math"
"math/rand"
"time"
)
// Quaternion represents q = w + Xi + Yj + Zk
type Quaternion struct {
W float64 // cos(theta/2)
X float64 // vx
Y float64 // vy
Z float64 // vz
}
// Norm returns the norm of the quaternion
func (q *Quaternion) Norm() float64 {
return math.Sqrt(q.W*q.W + q.X*q.X + q.Y*q.Y + q.Z*q.Z)
}
// Normalized normalize quanternion norm to 1 (necessary for rotation)
func (q *Quaternion) Normalized() {
qnorm := q.Norm()
q.W = q.W / qnorm
q.X = q.X / qnorm
q.Y = q.Y / qnorm
q.Z = q.Z / qnorm
}
// Normalize returns the normalized quaternion
func (q *Quaternion) Normalize() Quaternion {
qnorm := q.Norm()
return Quaternion{
W: q.W / qnorm,
X: q.X / qnorm,
Y: q.Y / qnorm,
Z: q.Z / qnorm,
}
}
// Conjugated convert the quaternion to its conjugate
func (q *Quaternion) Conjugated() {
q.X = -q.X
q.Y = -q.Y
q.Z = -q.Z
}
// Conjugate returns the conjugate of the quaternion
func (q *Quaternion) Conjugate() Quaternion {
return Quaternion{
W: q.W,
X: -q.X,
Y: -q.Y,
Z: -q.Z,
}
}
// Mul multiply self with new quaternion, representing continuous rotation
func (q *Quaternion) Mul(q2 Quaternion) Quaternion {
Aw := q.W
Ax := q.X
Ay := q.Y
Az := q.Z
Bw := q2.W
Bx := q2.X
By := q2.Y
Bz := q2.Z
return Quaternion{
W: -Ax*Bx - Ay*By - Az*Bz + Aw*Bw,
X: +Ax*Bw + Ay*Bz - Az*By + Aw*Bx,
Y: -Ax*Bz + Ay*Bw + Az*Bx + Aw*By,
Z: +Ax*By - Ay*Bx + Az*Bw + Aw*Bz,
}
}
// Diff returns the total difference between two quaternions
func (q *Quaternion) Diff(q2 Quaternion) float64 {
delta1 := math.Abs(q.W - q2.W + q.X - q2.X + q.Y - q2.Y + q.Z - q2.Z)
delta2 := math.Abs(-q.W - q2.W - q.X - q2.X - q.Y - q2.Y - q.Z - q2.Z)
if delta1 < delta2 {
return delta1
}
return delta2
}
// AsArray returns the quaternion as a simple float64 array
func (q *Quaternion) AsArray() [4]float64 {
return [4]float64{q.W, q.X, q.Y, q.Z}
}
// AsQuaternion returns a copy of the given quaternion
func (q *Quaternion) AsQuaternion() Quaternion {
return Quaternion{W: q.W, X: q.X, Y: q.Y, Z: q.Z}
}
// AsBungeEulers returns the Euler angles equivalent of the quaternion
// Orientation as Bunge-Euler angles.
// Conversion of ACTIVE rotation to Euler angles taken from:
// <NAME>.; <NAME>.; <NAME>.; <NAME>.; <NAME>.; <NAME>.
// Conversion of EBSD data by a quaternion based algorithm to be used for grain structure simulations
// Technische Mechanik 30 (2010) pp 401--413.
func (q *Quaternion) AsBungeEulers(indegree bool) [3]float64 {
eulers := [3]float64{0, 0, 0}
if (math.Abs(q.X) < 1e-10) && (math.Abs(q.Y) < 1e-10) {
cosphi1 := q.W*q.W - q.Z*q.Z
sinphi1 := 2 * q.W * q.Z
eulers[0] = math.Atan2(sinphi1, cosphi1)
} else if (math.Abs(q.W) < 1e-10) && (math.Abs(q.Z) < 1e-10) {
cosphi1 := q.X*q.X - q.Y*q.Y
sinphi1 := 2 * q.X * q.Y
eulers[0] = math.Atan2(sinphi1, cosphi1)
eulers[1] = math.Pi // PHI = pi
} else {
chi := math.Sqrt((q.W*q.W + q.Z*q.Z) * (q.X*q.X + q.Y*q.Y))
x := (q.W*q.X - q.Y*q.Z) / 2. / chi
y := (q.W*q.Y + q.X*q.Z) / 2. / chi
eulers[0] = math.Atan2(y, x)
x = q.W*q.W + q.Z*q.Z - (q.X*q.X + q.Y*q.Y)
y = 2 * chi
eulers[1] = math.Atan2(y, x)
x = (q.W*q.X + q.Y*q.Z) / 2. / chi
y = (q.Z*q.X - q.Y*q.W) / 2. / chi
eulers[2] = math.Atan2(y, x)
}
if indegree {
for i, v := range eulers {
eulers[i] = v / math.Pi * 180
}
}
return eulers
}
// FromMatrix set the quaternion with given rotation matrix
// Modified Method to calculate Quaternion from Orientation Matrix,
// Source: http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToQuaternion/
func (q *Quaternion) FromMatrix(r [3][3]float64) {
tr := r[0][0] + r[1][1] + r[2][2]
s := math.Sqrt(tr+1) * 2.0
if math.Abs(tr) > 1e-8 {
q.W = s * 0.25
q.X = (r[2][1] - r[1][2]) / s
q.Y = (r[0][2] - r[2][0]) / s
q.Z = (r[1][0] - r[0][1]) / s
} else if (r[0][0] > r[1][1]) && (r[0][0] > r[2][2]) {
t := r[0][0] - r[1][1] - r[2][2] + 1.0
s = 2.0 * math.Sqrt(t)
q.W = (r[2][1] - r[1][2]) / s
q.X = s * 0.25
q.Y = (r[0][1] + r[1][0]) / s
q.Z = (r[2][0] + r[0][2]) / s
} else if r[1][1] > r[2][2] {
t := -r[0][0] + r[1][1] - r[2][2] + 1.0
s = 2.0 * math.Sqrt(t)
q.W = (r[0][2] - r[2][0]) / s
q.X = (r[0][1] + r[1][0]) / s
q.Y = s * 0.25
q.Z = (r[1][2] + r[2][1]) / s
} else {
t := -r[0][0] - r[1][1] + r[2][2] + 1.0
s = 2.0 * math.Sqrt(t)
q.W = (r[1][0] - r[0][1]) / s
q.X = (r[2][0] + r[0][2]) / s
q.Y = (r[1][2] + r[2][1]) / s
q.Z = s * 0.25
}
}
// AsMatrix returns the rotation matrix equivalent of given quaternion
func (q *Quaternion) AsMatrix() [3][3]float64 {
m := [3][3]float64{}
m[0][0] = 1 - 2*(q.Y*q.Y+q.Z*q.Z)
m[0][1] = 2 * (q.X*q.Y - q.W*q.Z)
m[0][2] = 2 * (q.W*q.Y + q.X*q.Z)
m[1][0] = 2 * (q.W*q.Z + q.Y*q.X)
m[1][1] = 1 - 2*(q.Z*q.Z+q.X*q.X)
m[1][2] = 2 * (q.Y*q.Z - q.W*q.X)
m[2][0] = 2 * (q.Z*q.X - q.W*q.Y)
m[2][1] = 2 * (q.W*q.X + q.Z*q.Y)
m[2][2] = 1 - 2*(q.X*q.X+q.Y*q.Y)
return m
}
// RotateVec rotates a vector using the quaternion
func (q *Quaternion) RotateVec(v [3]float64) [3]float64 {
var rotatedV [3]float64
w := q.W
x := q.X
y := q.Y
z := q.Z
vx := v[0]
vy := v[1]
vz := v[2]
rotatedV[0] = w*w*vx + 2*y*w*vz - 2*z*w*vy + x*x*vx + 2*y*x*vy + 2*z*x*vz - z*z*vx - y*y*vx
rotatedV[1] = 2*x*y*vx + y*y*vy + 2*z*y*vz + 2*w*z*vx - z*z*vy + w*w*vy - 2*x*w*vz - x*x*vy
rotatedV[2] = 2*x*z*vx + 2*y*z*vy + z*z*vz - 2*w*y*vx - y*y*vz + 2*w*x*vy - x*x*vz + w*w*vz
return rotatedV
}
// ScaledBy scales the quanternion by given scalar
func (q *Quaternion) ScaledBy(s float64) {
q.W = q.W * s
q.X = q.X * s
q.Y = q.Y * s
q.Z = q.Z * s
}
// Random make a random quaternion vector with unit length
func (q *Quaternion) Random() {
s := rand.NewSource(time.Now().UnixNano())
r := rand.New(s)
v := [3]float64{r.Float64(), r.Float64(), r.Float64()}
q.W = math.Cos(2*math.Pi*v[0]) * math.Sqrt(v[2])
q.X = math.Sin(2*math.Pi*v[1]) * math.Sqrt(1-v[2])
q.Y = math.Cos(2*math.Pi*v[1]) * math.Sqrt(1-v[2])
q.Z = math.Sin(2*math.Pi*v[0]) * math.Sqrt(v[2])
}
// FromAngleAxis returns a quaternion converted from angle axis pair
func (q *Quaternion) FromAngleAxis(ang float64, axis [3]float64, indegree bool) {
if indegree {
ang = ang / 180 * math.Pi
}
axisVectorLen := math.Sqrt(axis[0]*axis[0] + axis[1]*axis[1] + axis[2]*axis[2])
q.W = math.Cos(ang / 2)
q.X = math.Sin(ang/2) * axis[0] / axisVectorLen
q.Y = math.Sin(ang/2) * axis[1] / axisVectorLen
q.Z = math.Sin(ang/2) * axis[2] / axisVectorLen
}
// AsAngleAxis returns the angle-axis pair representation of the orientation
func (q *Quaternion) AsAngleAxis(indegree bool) (ang float64, axis [3]float64) {
ang = math.Acos(q.W) * 2
norm := math.Sqrt(q.X*q.X + q.Y*q.Y + q.Z*q.Z)
axis = [3]float64{q.X / norm, q.Y / norm, q.Z / norm}
if indegree {
ang = ang / math.Pi * 180
}
return ang, axis
}
// FromBungeEulers returns a quaternion converted from given Bunge Euler angles
func (q *Quaternion) FromBungeEulers(eulers [3]float64, indegree bool) {
// convert to radians for calculation
if indegree {
for i, v := range eulers {
eulers[i] = v / 180 * math.Pi
}
}
var c [3]float64
var s [3]float64
for i, v := range eulers {
c[i] = math.Cos(v / 2)
s[i] = math.Sin(v / 2)
}
q.W = c[0]*c[1]*c[2] - s[0]*c[1]*s[2]
q.X = c[0]*s[1]*c[2] + s[0]*s[1]*s[2]
q.Y = -c[0]*s[1]*s[2] + s[0]*s[1]*c[2]
q.Z = c[0]*c[1]*s[2] + s[0]*c[1]*c[2]
} | orientation/quaternion.go | 0.866979 | 0.646655 | quaternion.go | starcoder |
package bring
import (
"image"
"image/draw"
"github.com/tfriedel6/canvas"
"github.com/tfriedel6/canvas/backend/softwarebackend"
)
type layer struct {
width int
height int
image *image.RGBA
gc *canvas.Canvas
visible bool
modified bool
modifiedRect image.Rectangle
pathOpen bool
pathRect image.Rectangle
autosize bool
}
func (l *layer) updateModifiedRect(modArea image.Rectangle) {
before := l.modifiedRect
l.modifiedRect = l.modifiedRect.Union(modArea)
l.modified = l.modified || !before.Eq(l.modifiedRect)
}
func (l *layer) resetModified() {
l.modifiedRect = image.Rectangle{}
l.modified = false
}
func (l *layer) setupCanvas() {
be := softwarebackend.New(l.width, l.height)
be.Image = l.image
l.gc = canvas.New(be)
}
func (l *layer) fitRect(x int, y int, w int, h int) {
rect := image.Rect(x, y, x+w, y+h)
final := l.image.Bounds().Union(rect)
l.Resize(final.Max.X, final.Max.Y)
}
func copyImage(dest draw.Image, x, y int, src image.Image, sr image.Rectangle, op draw.Op) {
dp := image.Pt(x, y)
dr := image.Rectangle{Min: dp, Max: dp.Add(sr.Size())}
draw.Draw(dest, dr, src, sr.Min, op)
}
func (l *layer) Copy(srcLayer *layer, srcx, srcy, srcw, srch, x, y int, op draw.Op) {
srcImg := srcLayer.image
srcDim := srcImg.Bounds()
// If entire rectangle outside source canvas, stop
if srcx >= srcDim.Max.X || srcy >= srcDim.Max.Y {
return
}
// Otherwise, clip rectangle to area
if srcx+srcw > srcDim.Max.X {
srcw = srcDim.Max.X - srcx
}
if srcy+srch > srcDim.Max.Y {
srch = srcDim.Max.Y - srcy
}
// Stop if nothing to draw.
if srcw == 0 || srch == 0 {
return
}
if l.autosize {
l.fitRect(x, y, srcw, srch)
}
srcCopyDim := image.Rect(srcx, srcy, srcx+srcw, srcy+srch)
copyImage(l.image, x, y, srcImg, srcCopyDim, op)
l.updateModifiedRect(image.Rect(x, y, x+srcw, y+srch))
}
func (l *layer) Draw(x, y int, src image.Image, op draw.Op) {
srcDim := src.Bounds()
if l.autosize {
l.fitRect(x, y, srcDim.Max.X, srcDim.Max.Y)
}
copyImage(l.image, x, y, src, srcDim, op)
l.updateModifiedRect(image.Rect(x, y, x+srcDim.Max.X, y+srcDim.Max.Y))
}
func (l *layer) Resize(w int, h int) {
original := l.image.Bounds()
if w == l.width && h == l.height {
return
}
newImage := image.NewRGBA(image.Rect(0, 0, w, h))
draw.Draw(newImage, l.image.Bounds(), l.image, image.Pt(0, 0), draw.Src)
l.image = newImage
l.width = w
l.height = h
l.setupCanvas()
l.updateModifiedRect(original.Union(l.image.Bounds()))
}
func (l *layer) appendToPath(rect image.Rectangle) {
if !l.pathOpen {
l.gc.BeginPath()
l.pathOpen = true
l.pathRect = image.Rectangle{}
}
l.pathRect = l.pathRect.Union(rect)
}
func (l *layer) endPath() {
l.updateModifiedRect(l.pathRect)
l.pathOpen = false
l.pathRect = image.Rectangle{}
}
func (l *layer) Rect(x int, y int, width int, height int) {
l.appendToPath(image.Rect(x, y, x+width, y+height))
l.gc.Rect(float64(x), float64(y), float64(width), float64(height))
}
func (l *layer) Fill(r byte, g byte, b byte, a byte, op draw.Op) {
// Ignores op, as the canvas library does not support it :/
l.gc.SetFillStyle(r, g, b, a)
l.gc.Fill()
l.endPath()
}
type layers map[int]*layer
func newLayers() layers {
ls := make(layers)
ls[0] = newBuffer()
ls[0].visible = true
return ls
}
func newBuffer() *layer {
l := &layer{
image: image.NewRGBA(image.Rect(0, 0, 0, 0)),
autosize: true,
}
l.setupCanvas()
return l
}
func newVisibleLayer(l0 *layer) *layer {
l := &layer{
width: l0.width,
height: l0.height,
image: image.NewRGBA(image.Rect(0, 0, l0.width, l0.height)),
visible: true,
}
l.setupCanvas()
return l
}
func (ls layers) getDefault() *layer {
return ls[0]
}
func (ls layers) get(id int) *layer {
if l, ok := ls[id]; ok {
return l
}
if id > 0 {
ls[id] = newVisibleLayer(ls[0])
} else {
ls[id] = newBuffer()
}
return ls[id]
}
func (ls layers) delete(id int) {
if id == 0 {
return
}
ls[0].updateModifiedRect(ls[id].image.Bounds())
ls[id].image = nil
ls[id] = nil
delete(ls, id)
} | layer.go | 0.619932 | 0.490602 | layer.go | starcoder |
package geo
import (
"github.com/golang/geo/s2"
)
// LoopIntersectionWithCell returns sub-loops which contain
// the intersection areas between the loop and a cell.
func LoopIntersectionWithCell(loop *s2.Loop, cell s2.Cell) []*s2.Loop {
if wrap := s2.LoopFromCell(cell); loop.ContainsCell(cell) {
return []*s2.Loop{wrap}
} else if wrap.Contains(loop) {
return []*s2.Loop{loop}
}
if !loop.IntersectsCell(cell) {
return nil
}
// create circular linked point lists for subject and clip
subj, clip := circularLoopFromCell(cell), circularLoopFromPoints(loop.Vertices())
// find intersections between subject and clip
// insert them into the loops
subj.DoEdges(func(a0, a1 *circularLoop) {
crosser := s2.NewEdgeCrosser(a0.Point, a1.Point)
clip.DoEdges(func(b0, b1 *circularLoop) {
if crosser.EdgeOrVertexCrossing(b0.Point, b1.Point) {
x := EdgeIntersection(s2.Edge{V0: a0.Point, V1: a1.Point}, s2.Edge{V0: b0.Point, V1: b1.Point})
a0.PushIntersection(x)
b0.PushIntersection(x)
}
})
})
// prepare result
var res []*s2.Loop
// traverse paths https://codepen.io/bsm/pen/rwPQOL?editors=0010
clip.Do(func(p *circularLoop) {
if !p.Done && p.Intersection && !cell.ContainsPoint(p.Prev().Point) && cell.ContainsPoint(p.Next().Point) {
pts := make([]s2.Point, 0, 4)
c1, c2 := p, subj
for i := 0; ; i++ {
pts = append(pts, c1.Point)
c1.Done = true
if c1 = c1.Next(); c1.Intersection {
c1, c2 = c2.Find(c1.Point), c1
}
if c1 == p {
break
}
}
res = append(res, s2.LoopFromPoints(pts))
}
})
return res
}
// FitLoop returns an un-normalised CellUnion approximating
// the surface covered by the loop, with the smallest
// cell being maxLevel.
func FitLoop(loop *s2.Loop, acc s2.CellUnion, maxLevel int) s2.CellUnion {
FitLoopDo(loop, maxLevel, func(cellID s2.CellID) bool {
acc = append(acc, cellID)
return true
})
return acc
}
// FitLoopDo iterates over the cells of a loop and their LoopOverlap, with the smallest
// cell being maxLevel. Return false in the iterator to stop the loop.
func FitLoopDo(loop *s2.Loop, maxLevel int, fn func(s2.CellID) bool) {
for i := 0; i < 6; i++ {
cellID := s2.CellIDFromFace(i)
if nxt := fitLoopDo(loop, cellID, maxLevel, fn); !nxt {
return
}
}
}
func fitLoopDo(loop *s2.Loop, cellID s2.CellID, maxLevel int, fn func(s2.CellID) bool) bool {
cell := s2.CellFromCellID(cellID)
if loop.ContainsCell(cell) {
return fn(cellID)
} else if loop.IntersectsCell(cell) {
if cell.Level() == maxLevel {
return fn(cellID)
} else {
for _, childID := range cellID.Children() {
if !fitLoopDo(loop, childID, maxLevel, fn) {
return false
}
}
}
}
return true
} | geo/loop.go | 0.684475 | 0.553747 | loop.go | starcoder |
package statext
import (
"gonum.org/v1/gonum/mathext"
"math"
)
const (
maxDepth = 50 // Integrate to at most this depth (should never be reached)
minDepth = 2 // Integrate to at least this depth
)
// dirichletWinnerAdaptiveQuadFunc is the function to integrate for the
// dirichlet winner probs.
// Works in-place on result array.
func dirichletWinnerAdaptiveQuadFunc(avgAlpha, y float64, alphas, result, lgammas []float64) {
if y == 0.0 || y == 1.0 {
for j := 0; j < len(result); j++ {
result[j] = 0.0
}
return
}
x := avgAlpha * y / (1 - y)
cdfs := 1.0
var pdf, cdf float64
// Computes gamma(alphas[j]).pdf(x)*product(gamma(alphas[i]).cdf(x), i!=j) for each j
// Made faster by doing a single loop to compute each gamma(alphas[j]).pdf(x)/gamma(alphas[j]).cdf(x)
// And in the same loop computing product(gamma(alphas[j]).cdf(x))
// Then computing the final result by multiplying the pdf/cdf fractions by the cdfs product.
for j, alpha := range alphas {
pdf = math.Exp(math.Log(x)*(alpha-1) - x - lgammas[j])
cdf = mathext.GammaIncReg(alpha, x)
if cdf == 0.0 {
result[j] = 0.0
cdfs = 0.0
continue
}
result[j] = pdf / cdf
cdfs *= cdf
}
for j := 0; j < len(result); j++ {
result[j] *= avgAlpha * cdfs / ((1 - y) * (1 - y))
}
}
// dirichletWinnerAdaptiveQuadRecursive implements an adaptive quadrature
// integration over dirichletWinnerAdaptiveQuadFunc.
// Works in-place on result array.
func dirichletWinnerAdaptiveQuadRecursive(tol, avgAlpha, s, e float64, fs, fe, alphas, result, lgammas, ft []float64, depth, mnDepth int) {
n := len(result)
if depth == maxDepth {
for i := 0; i < n; i++ {
// Average the endpoints and return
result[i] += (fs[i] + fe[i]) * (e - s) / 2
}
//panic("Max depth")
return
}
var Q, Q2 float64
dirichletWinnerAdaptiveQuadFunc(avgAlpha, (s+e)/2, alphas, ft[:n], lgammas)
for i := 0; i < n; i++ {
Q = (fs[i] + fe[i]) * (e - s) / 2
Q2 = (fs[i] + 4*ft[i] + fe[i]) * (e - s) / 6
if math.Abs(Q-Q2) >= tol || depth < mnDepth {
// Error too large, divide
dirichletWinnerAdaptiveQuadRecursive(tol, avgAlpha, s, (s+e)/2, fs, ft[:n], alphas, result, lgammas, ft[n:], depth+1, mnDepth) // Left-half integration
dirichletWinnerAdaptiveQuadRecursive(tol, avgAlpha, (s+e)/2, e, ft[:n], fe, alphas, result, lgammas, ft[n:], depth+1, mnDepth) // Right-half integration
return
}
}
// Small enough error, return
for i := 0; i < n; i++ {
result[i] += (fs[i] + 4*ft[i] + fe[i]) * (e - s) / 6
}
}
// DirichletWinner computes the probabilities that each
// output value of the Dirichlet distribution will be the largest.
// Uses an adaptive quadrature integration technique with the
func DirichletWinner(alphas []float64, tol float64) []float64 {
n := len(alphas)
result := make([]float64, n)
if n == 1 {
result[0] = 1.0
return result
}
if n == 2 {
b := mathext.RegIncBeta(alphas[0], alphas[1], 0.5)
result[0] = 1.0 - b
result[1] = b
return result
}
lgammas := make([]float64, n)
// Pre-computed average of alpha values
// Used to improve integration accuracy by focusing around the critical points
var avgAlpha float64
for j, alpha := range alphas {
lgammas[j], _ = math.Lgamma(alpha)
avgAlpha += alpha
}
avgAlpha /= float64(n)
fs := make([]float64, n) // function result at start point (0.0)
fe := make([]float64, n) // function result at end point (1.0)
ft := make([]float64, maxDepth*n) // Buffer space to use as fs/fe at lower depths
dirichletWinnerAdaptiveQuadFunc(avgAlpha, 0.0, alphas, fs, lgammas) // Compute start point function result
dirichletWinnerAdaptiveQuadFunc(avgAlpha, 1.0, alphas, fe, lgammas) // Compute end point function result
for md := minDepth; md < maxDepth; md++ {
dirichletWinnerAdaptiveQuadRecursive(tol, avgAlpha, 0.0, 1.0, fs, fe, alphas, result, lgammas, ft, 0, md)
var sr float64
for _, v := range result {
sr += v
}
if math.Abs(sr-1) <= float64(2*n)*tol {
break
}
for i := range result {
result[i] = 0
}
}
return result
} | dirichletwinner.go | 0.601359 | 0.440048 | dirichletwinner.go | starcoder |
package exported
import (
"fmt"
ics23 "github.com/confio/ics23/go"
"github.com/cosmos/iavl"
)
// IavlSpec constrains the format from ics23-iavl (iavl merkle ics23)
var IavlSpec = &ics23.ProofSpec{
LeafSpec: &ics23.LeafOp{
Prefix: []byte{0},
Hash: ics23.HashOp_SHA256,
PrehashValue: ics23.HashOp_SHA256,
Length: ics23.LengthOp_VAR_PROTO,
},
InnerSpec: &ics23.InnerSpec{
ChildOrder: []int32{0, 1},
MinPrefixLength: 4,
MaxPrefixLength: 12,
ChildSize: 33, // (with length byte)
Hash: ics23.HashOp_SHA256,
},
}
/*
CreateMembershipProof will produce a CommitmentProof that the given key (and queries value) exists in the iavl tree.
If the key doesn't exist in the tree, this will return an error.
*/
func CreateMembershipProof(tree *iavl.MutableTree, key []byte) (*ics23.CommitmentProof, error) {
exist, err := createExistenceProof(tree, key)
if err != nil {
return nil, err
}
proof := &ics23.CommitmentProof{
Proof: &ics23.CommitmentProof_Exist{
Exist: exist,
},
}
return proof, nil
}
/*
CreateNonMembershipProof will produce a CommitmentProof that the given key doesn't exist in the iavl tree.
If the key exists in the tree, this will return an error.
*/
func CreateNonMembershipProof(tree *iavl.MutableTree, key []byte) (*ics23.CommitmentProof, error) {
// idx is one node right of what we want....
idx, val := tree.Get(key)
if val != nil {
return nil, fmt.Errorf("Cannot create NonExistanceProof when Key in State")
}
var err error
nonexist := &ics23.NonExistenceProof{
Key: key,
}
if idx >= 1 {
leftkey, _ := tree.GetByIndex(idx - 1)
nonexist.Left, err = createExistenceProof(tree, leftkey)
if err != nil {
return nil, err
}
}
// this will be nil if nothing right of the queried key
rightkey, _ := tree.GetByIndex(idx)
if rightkey != nil {
nonexist.Right, err = createExistenceProof(tree, rightkey)
if err != nil {
return nil, err
}
}
proof := &ics23.CommitmentProof{
Proof: &ics23.CommitmentProof_Nonexist{
Nonexist: nonexist,
},
}
return proof, nil
}
func createExistenceProof(tree *iavl.MutableTree, key []byte) (*ics23.ExistenceProof, error) {
value, proof, err := tree.GetWithProof(key)
if err != nil {
return nil, err
}
if value == nil {
return nil, fmt.Errorf("Cannot create ExistanceProof when Key not in State")
}
return convertExistenceProof(proof, key, value)
} | x/anconprotocol/exported/create_iavl_proof.go | 0.554229 | 0.408749 | create_iavl_proof.go | starcoder |
package value
import (
"errors"
"fmt"
)
// An environment maintains a set of bindings that are typically
// referenced when evaluating a Lisp expression.
type Environment interface {
Value
// Returns the list of defined symbols.
Names() []string
// Lookup the value of a symbol.
Lookup(name string) (Value, bool)
// Define a new symbol.
Define(name string, value Value)
// Update the value of a symbol.
Update(name string, value Value) error
}
var equalFn = Func2(equal)
// SystemEnvironment is the toplevel environment where primitives are
// defined.
var SystemEnvironment = &env{
env: map[string]Value{
"atom": Func1(atom),
"null": Func1(null),
"eq": equalFn, // alias
"equal": equalFn,
"car": Func1(car),
"cdr": Func1(cdr),
"caar": Func1(caar),
"cadr": Func1(cadr),
"cddr": Func1(cddr),
"caddr": Func1(caddr),
"cadar": Func1(cadar),
"caddar": Func1(caddar),
"cons": Func2(func(x, y Value) Value { return Cons(x, y) }),
"list": FuncN(list),
"apply": FuncN(apply),
// Error Primitives
"error": FuncN(raiseError),
"ignore-errors": Func1(trapError),
// Environment Primitives
"environment-bindings": EnvFunc(bindings),
},
}
// FuncEnv creates a Function value from a native Go function that
// only accepts environments.
func EnvFunc(fn func(Environment) Value) Function {
return Func1(func(v Value) Value {
env, ok := v.(Environment)
if !ok {
Errorf("%s is not an environment", v)
}
return fn(env)
})
}
func init() {
SystemEnvironment.Define("system-environment", SystemEnvironment)
}
// NewEnv returns a new environment that extends the bindings of
// parent. If parent is nil, then this is a toplevel environment.
func NewEnv(parent Environment) Environment {
return &env{
env: make(map[string]Value),
parent: parent,
}
}
type env struct {
env map[string]Value
parent Environment
}
func (e *env) String() string {
return fmt.Sprintf("#[env %p %d]", e, len(e.env))
}
// Equal implments the Value interface, and returns T for the same
// environment.
func (e *env) Equal(cmp Value) Value {
if x, ok := cmp.(*env); ok && e == x {
return T
}
return NIL
}
// Names implements the Environment interface, returning a list of all
// defined symbols.
func (e *env) Names() []string {
names := make([]string, 0, len(e.env))
for k := range e.env {
names = append(names, k)
}
return names
}
// Define implements the Environment interface.
func (e *env) Define(name string, value Value) {
e.env[name] = value
}
// Lookup implements the Environment interface.
func (e *env) Lookup(name string) (Value, bool) {
if v, ok := e.env[name]; ok {
return v, true
}
if e.parent == nil {
return nil, false
}
return e.parent.Lookup(name)
}
// Update implements the Environment interface.
func (e *env) Update(name string, value Value) error {
if _, ok := e.env[name]; ok {
e.env[name] = value
return nil
}
// Only define can introduce new bindings.
if e.parent == nil {
return errors.New("no such binding")
}
return e.parent.Update(name, value)
} | value/env.go | 0.770465 | 0.459622 | env.go | starcoder |
package tfbparser
import (
"strconv"
"strings"
"github.com/PRETgroup/goFB/iec61499"
)
//parseHFBarchitecture shall only be called once we have already parsed the
// "architecture of [blockname]" part of the definition
// so, we are up to the brace
func (t *tfbParse) parseHFBarchitecture(fbIndex int) *ParseError {
if s := t.pop(); s != pOpenBrace {
return t.errorUnexpectedWithExpected(s, pOpenBrace)
}
//we now have several things that could be in here
//internal | internals | location | locations | algorithm | algorithms | closeBrace
//unlike in an interface, the various things that are in an architecture can be presented out of order
//this only has consequences with regards to states in the state machine
//because we can't verify them "on-the-fly" (a state might point to a state we've not yet parsed)
//Situations like this is the main reason most non-syntax parse-related validation is done in the iec61499 package
for {
s := t.pop()
if s == "" {
return t.error(ErrUnexpectedEOF)
} else if s == pCloseBrace {
//this is the end of the architecture
break
} else if s == pInternal || s == pInternals { //we actually care about { vs not-{, and so either internal or internals are valid prefixes for both situations
//we're cheeky here, and take advantage of the fact that BFB and HFB internals are identical
//the function parseBFBInternal can parse HFB internals as well
if err := t.parsePossibleArrayInto(fbIndex, (*tfbParse).parseBFBInternal); err != nil {
return err
}
} else if s == pAlgorithm || s == pAlgorithms {
if err := t.parsePossibleArrayInto(fbIndex, (*tfbParse).parseHFBAlgorithm); err != nil {
return err
}
} else if s == pLocation || s == pLocations {
if err := t.parsePossibleArrayInto(fbIndex, (*tfbParse).parseHFBLocation); err != nil {
return err
}
}
}
return nil
}
//parseHFBLocation parses a single location and adds it to fb identified by fbIndex
// remember that HFBs will be translated into BFBs as soon as they are parsed, hence
// most things in this function are validated later in the iec61499 package
func (t *tfbParse) parseHFBLocation(fbIndex int) *ParseError {
fb := &t.fbs[fbIndex]
//next is name of state
name := t.pop()
anonAlgIndex := 0 //used to count anonymous algorithms (to give them unique names)
for _, st := range fb.BasicFB.States {
if st.Name == name {
return t.errorWithArg(ErrNameAlreadyInUse, name)
}
}
debug := t.getCurrentDebugInfo()
//next should be open brace
if s := t.pop(); s != pOpenBrace {
return t.errorUnexpectedWithExpected(s, pOpenBrace)
}
//now we have an unknown number of runs, emits, and ->s
var runs []iec61499.Action
var emits []iec61499.Action
var invariants []iec61499.HFBInvariant
for {
s := t.pop()
if s == "" {
return t.error(ErrUnexpectedEOF)
}
if s == pCloseBrace {
break
}
if s == pInvariant {
//capture any number of comma-separated invariants (invariants are surrounded by backticks)
//should terminate with semicolon
for {
inv := t.pop()
if len(inv) == 0 {
return t.error(ErrUnexpectedEOF)
}
if inv[0] == '`' && inv[len(inv)-1] == '`' {
inv = strings.Trim(inv, "`")
} else {
return t.errorWithReason(ErrUnexpectedValue, "Invariants should be surrounded by backticks")
}
invariants = append(invariants, iec61499.HFBInvariant{Invariant: inv, DebugInfo: t.getCurrentDebugInfo()})
if t.peek() == pComma {
t.pop()
continue
}
break
}
if s := t.pop(); s != pSemicolon {
return t.errorUnexpectedWithExpected(s, pSemicolon)
}
}
if s == pRun {
//capture any number of comma-separated algorithms to run
for {
r := t.pop()
if len(r) == 0 {
return t.error(ErrUnexpectedEOF)
}
if r[0] == '`' && r[len(r)-1] == '`' {
//we have a program, an anonymous algorithm here (identified by backtick surrounds)
prog := strings.Trim(r, "`")
anonAlgName := name + "_alg" + strconv.Itoa(anonAlgIndex)
anonAlgIndex++
//we're done here, add the algorithm to the block
fb.HybridFB.AddAlgorithm(anonAlgName, prog, debug)
//replace program with the name of the new anon algorithm so it can be joined properly
r = anonAlgName
} else if r[0] == '`' || r[len(r)-1] == '`' {
//only one side of the program has a backtick
return t.errorWithReason(ErrUnexpectedValue, "Language program should be surrounded by backticks")
}
runs = append(runs, iec61499.Action{Algorithm: r, DebugInfo: t.getCurrentDebugInfo()})
if t.peek() == pComma {
t.pop()
continue
}
break
}
if s := t.pop(); s != pSemicolon {
return t.errorUnexpectedWithExpected(s, pSemicolon)
}
}
if s == pEmit {
//capture any number of comma-separated events to emit
for {
e := t.pop()
emits = append(emits, iec61499.Action{Output: e, DebugInfo: t.getCurrentDebugInfo()})
if t.peek() == pComma {
t.pop()
continue
}
break
}
if s := t.pop(); s != pSemicolon {
return t.errorUnexpectedWithExpected(s, pSemicolon)
}
}
if s == pTrans {
//next is dest state
destState := t.pop()
debug := t.getCurrentDebugInfo()
var condComponents []string
//next is on if we have a condition
if t.peek() == pOn {
if s := t.pop(); s != pOn {
return t.errorUnexpectedWithExpected(s, pOn)
}
//now we have an unknown number of condition components, terminated by a semicolon
for {
s := t.pop()
if s == "" {
return t.error(ErrUnexpectedEOF)
}
if s == pSemicolon {
break
}
condComponents = append(condComponents, s)
}
//TODO: emitting/running things on transitions?!
}
if len(condComponents) == 0 { //put in a default condition if no condition exists
condComponents = append(condComponents, "true")
}
//save the transition
fb.BasicFB.AddTransition(name, destState, strings.Join(condComponents, " "), debug)
}
}
//everything is parsed, add it to the state machine
fb.HybridFB.AddLocation(name, invariants, append(emits, runs...), debug)
return nil
}
//parseHFBAlgorithm parses a single algorithm and adds it to fb identified by fbIndex
//Notice that HFB algorithms differ to BFB algorithms and don't allow specification of language
func (t *tfbParse) parseHFBAlgorithm(fbIndex int) *ParseError {
fb := &t.fbs[fbIndex]
//next word is algorithm name
name := t.pop()
debug := t.getCurrentDebugInfo()
//next item should be the program surrounded by backticks
prog := t.pop()
if len(prog) == 0 {
return t.error(ErrUnexpectedEOF)
}
if prog[0] != '`' || prog[len(prog)-1] != '`' {
return t.errorWithReason(ErrUnexpectedValue, "Language program should be surrounded by backticks")
}
prog = strings.Trim(prog, "`")
//next item should be semicolon
if s := t.pop(); s != pSemicolon {
return t.errorUnexpectedWithExpected(s, pSemicolon)
}
//we're done here, add the algorithm to the block
fb.HybridFB.AddAlgorithm(name, prog, debug)
return nil
} | goTFB/tfbparser/parseHFBarchitecture.go | 0.560854 | 0.466177 | parseHFBarchitecture.go | starcoder |
package sudogo
// A cell holds a value or possible values in a Sudoku puzzle.
type Cell struct {
// The Value in the cell or 0 if a no Value exists yet.
Value int
// The unique Id of the cell. This is also the index of this cell in the puzzle's cells slice.
Id int
// The zero-based Row this cell is in.
Row int
// The zero-based column this cell is in.
Col int
// The zero-based Box this cell is in which starts in the top left of the puzzle and goes right and then restarts on the left side for the next row.
Box int
// The possible values in the cell if there is no value.
candidates Candidates
// The constrains applicable for this cell.
Constraints []Constraint
}
type Group int
const (
GroupCol Group = iota
GroupRow
GroupBox
)
// Returns whether this cell has a value in it.
func (cell *Cell) HasValue() bool {
return cell.Value != 0
}
// Returns this cell is empty (does not have a value in it).
func (cell *Cell) Empty() bool {
return cell.Value == 0
}
// Returns if this cell is valid, meaning the value and candidates it has match. If this returns false then there is a logical error in the software.
func (cell *Cell) Valid() bool {
return (cell.Value != 0) == (cell.candidates.Value == 0)
}
// Returns the group given its index. The group order starting with zero is Col, Row, Box.
func (cell *Cell) GetGroup(groupIndex Group) int {
if groupIndex == GroupCol {
return cell.Col
} else if groupIndex == GroupRow {
return cell.Row
} else {
return cell.Box
}
}
// Returns whether this cell and the given cell are in the same group (box, column, or row).
func (cell *Cell) InGroup(other *Cell) bool {
return cell.Id != other.Id && (cell.Row == other.Row || cell.Col == other.Col || cell.Box == other.Box)
}
// Returns whether this cell and the given cell are in the same box.
func (cell *Cell) InBox(other *Cell) bool {
return cell.Id != other.Id && cell.Box == other.Box
}
// Returns whether this cell and the given cell are in the same row.
func (cell *Cell) InRow(other *Cell) bool {
return cell.Id != other.Id && cell.Row == other.Row
}
// Returns whether this cell and the given cell are in the same column.
func (cell *Cell) InColumn(other *Cell) bool {
return cell.Id != other.Id && cell.Col == other.Col
}
// Removes the given candidate from this cell and returns whether it existed in the first place.
func (cell *Cell) RemoveCandidate(value int) bool {
return cell.candidates.Set(value, false)
}
// Determines if this cell has the given candidate.
func (cell *Cell) HasCandidate(value int) bool {
return cell.candidates.Has(value)
}
// Attempts to set the value of this cell. If this cell already has a value or doesn't have the given value as a candidate
// then false will be returned. Otherwise if the value is applied then true is returned.
func (cell *Cell) SetValue(value int) bool {
can := cell.candidates.Has(value)
if can {
cell.Value = value
cell.candidates.Clear()
}
return can
}
// Returns the candidates that exists in this cell as a slice of ints.
func (cell *Cell) Candidates() []int {
return cell.candidates.ToSlice()
}
// Returns the smallest candidate available in this cell. If none exist then 64 is returned.
func (cell *Cell) FirstCandidate() int {
return cell.candidates.First()
}
// Returns the largest candidate available in this cell. If none exist then 0 is returned.
func (cell *Cell) LastCandidate() int {
return cell.candidates.Last()
}
// The minimum value this cell can possibly be, taking into account it might
// already have a value and therefore no candidates.
func (cell *Cell) MinValue() int {
if cell.HasValue() {
return cell.Value
} else {
return cell.FirstCandidate()
}
}
// The maximum value this cell can possibly be, taking into account it might
// already have a value and therefore no candidates.
func (cell *Cell) MaxValue() int {
if cell.HasValue() {
return cell.Value
} else {
return cell.LastCandidate()
}
} | pkg/cell.go | 0.781706 | 0.707291 | cell.go | starcoder |
package parser
import (
"github.com/kasperisager/pak/pkg/asset/html/ast"
"github.com/kasperisager/pak/pkg/asset/html/token"
)
type SyntaxError struct {
Offset int
Message string
}
func (err SyntaxError) Error() string {
return err.Message
}
func Parse(tokens []token.Token) (*ast.Document, error) {
offset, tokens, document, err := parseDocument(0, tokens)
if err != nil {
return nil, err
}
offset, tokens = skipWhitespace(offset, tokens)
if len(tokens) > 0 {
return nil, SyntaxError{
Offset: offset,
Message: "unexpected token",
}
}
return document, nil
}
func parseDocument(offset int, tokens []token.Token) (int, []token.Token, *ast.Document, error) {
offset, tokens = skipWhitespace(offset, tokens)
switch peek(tokens, 1).(type) {
case token.DocumentType:
offset, tokens = offset+1, tokens[1:]
default:
return offset, tokens, nil, SyntaxError{
Offset: offset,
Message: "unexpected token, expected <!doctype html>",
}
}
offset, tokens, documentElement, err := parseDocumentElement(offset+1, tokens[1:])
if err != nil {
return offset, tokens, nil, err
}
return offset, tokens, &ast.Document{Root: documentElement}, nil
}
func parseDocumentElement(offset int, tokens []token.Token) (int, []token.Token, *ast.Element, error) {
documentElement := &ast.Element{Name: "html"}
offset, tokens = skipWhitespace(offset, tokens)
switch next := peek(tokens, 1).(type) {
case token.StartTag:
switch next.Name {
case "html":
documentElement = createElement(next)
offset, tokens = offset+1, tokens[1:]
}
case token.EndTag:
switch next.Name {
case "html", "head", "body":
default:
return offset, tokens, nil, SyntaxError{
Offset: offset,
Message: "unexpected end tag, expected <html> tag",
}
}
case token.DocumentType:
return offset, tokens, nil, SyntaxError{
Offset: offset,
Message: "unexpected doctype, expected <html> tag",
}
}
offset, tokens, head, err := parseHead(offset, tokens)
if err != nil {
return offset, tokens, nil, err
}
offset, tokens, body, err := parseBody(offset, tokens)
if err != nil {
return offset, tokens, nil, err
}
documentElement.Children = []ast.Node{head, body}
offset, tokens = skipWhitespace(offset, tokens)
switch next := peek(tokens, 1).(type) {
case token.EndTag:
switch next.Name {
case "html":
offset, tokens = offset+1, tokens[1:]
}
}
return offset, tokens, documentElement, nil
}
func parseHead(offset int, tokens []token.Token) (int, []token.Token, *ast.Element, error) {
head := &ast.Element{Name: "head"}
offset, tokens = skipWhitespace(offset, tokens)
switch next := peek(tokens, 1).(type) {
case token.StartTag:
switch next.Name {
case "head":
head = createElement(next)
offset, tokens = offset+1, tokens[1:]
case "html":
return offset, tokens, nil, SyntaxError{
Offset: offset,
Message: "unexpected token tag, expected <head> tag",
}
}
case token.EndTag:
switch next.Name {
case "html", "head", "body":
default:
return offset, tokens, nil, SyntaxError{
Offset: offset,
Message: "unexpected token, expected <head> tag",
}
}
case token.DocumentType:
return offset, tokens, nil, SyntaxError{
Offset: offset,
Message: "unexpected token, expected <html> tag",
}
}
for len(tokens) > 0 {
var (
child *ast.Element
err error
)
offset, tokens, child, err = parseHeadChild(offset, tokens)
if err != nil {
return offset, tokens, nil, err
}
if child == nil {
break
}
head.Children = append(head.Children, child)
}
switch next := peek(tokens, 1).(type) {
case token.EndTag:
switch next.Name {
case "head":
offset, tokens = offset+1, tokens[1:]
}
}
return offset, tokens, head, nil
}
func parseHeadChild(offset int, tokens []token.Token) (int, []token.Token, *ast.Element, error) {
offset, tokens = skipWhitespace(offset, tokens)
switch next := peek(tokens, 1).(type) {
case token.StartTag:
switch next.Name {
case "base", "link", "meta":
element := createElement(next)
return offset + 1, tokens[1:], element, nil
case "title", "script", "style":
offset, tokens, text, err := parseText(offset+1, tokens[1:])
if err != nil {
return offset, tokens, nil, err
}
element := createElement(next)
if text != nil {
element.Children = append(element.Children, text)
}
switch next := peek(tokens, 1).(type) {
case token.EndTag:
if next.Name == element.Name {
return offset + 1, tokens[1:], element, nil
}
return offset, tokens, nil, SyntaxError{
Offset: offset,
Message: "unexpected token, expected <" + element.Name + "> tag",
}
}
}
}
return offset, tokens, nil, nil
}
func parseBody(offset int, tokens []token.Token) (int, []token.Token, *ast.Element, error) {
body := &ast.Element{Name: "body"}
offset, tokens = skipWhitespace(offset, tokens)
switch next := peek(tokens, 1).(type) {
case token.StartTag:
switch next.Name {
case "body":
body = createElement(next)
offset, tokens = offset+1, tokens[1:]
case "html", "head":
return offset, tokens, nil, SyntaxError{
Offset: offset,
Message: "unexpected token, expected <body> tag",
}
}
case token.EndTag:
switch next.Name {
case "html", "head", "body":
default:
return offset, tokens, nil, SyntaxError{
Offset: offset,
Message: "unexpected token, expected <body> tag",
}
}
case token.DocumentType:
return offset, tokens, nil, SyntaxError{
Offset: offset,
Message: "unexpected doctype, expected <body> tag",
}
}
for len(tokens) > 0 {
var (
child ast.Node
err error
)
offset, tokens, child, err = parseBodyChild(offset, tokens)
if err != nil {
return offset, tokens, nil, err
}
if child == nil {
break
}
body.Children = append(body.Children, child)
}
switch next := peek(tokens, 1).(type) {
case token.EndTag:
switch next.Name {
case "body":
offset, tokens = offset+1, tokens[1:]
}
}
return offset, tokens, body, nil
}
func parseBodyChild(offset int, tokens []token.Token) (int, []token.Token, ast.Node, error) {
switch next := peek(tokens, 1).(type) {
case token.StartTag:
element := createElement(next)
offset, tokens = offset+1, tokens[1:]
if element.IsVoid() {
return offset, tokens, element, nil
}
for {
switch next := peek(tokens, 1).(type) {
case token.EndTag:
if next.Name == element.Name {
return offset + 1, tokens[1:], element, nil
}
return offset, tokens, nil, SyntaxError{
Offset: offset,
Message: "unexpected token, expected <" + element.Name + "> tag",
}
default:
var (
child ast.Node
err error
)
offset, tokens, child, err = parseBodyChild(offset, tokens)
if err != nil {
return offset, tokens, nil, err
}
if child != nil {
element.Children = append(element.Children, child)
}
}
}
case token.Character:
return parseText(offset, tokens)
}
return offset, tokens, nil, nil
}
func parseText(offset int, tokens []token.Token) (int, []token.Token, *ast.Text, error) {
var runes []rune
for len(tokens) > 0 {
switch next := peek(tokens, 1).(type) {
case token.Character:
runes = append(runes, next.Data)
offset, tokens = offset+1, tokens[1:]
continue
}
break
}
if runes == nil {
return offset, tokens, nil, nil
}
return offset, tokens, &ast.Text{Data: string(runes)}, nil
}
func createElement(tag token.StartTag) *ast.Element {
element := &ast.Element{Name: tag.Name}
for _, attribute := range tag.Attributes {
element.Attributes = append(element.Attributes, &ast.Attribute{
Name: attribute.Name,
Value: attribute.Value,
})
}
return element
}
func peek(tokens []token.Token, n int) token.Token {
if len(tokens) < n {
return nil
}
return tokens[n-1]
}
func skipWhitespace(offset int, tokens []token.Token) (int, []token.Token) {
for {
switch next := peek(tokens, 1).(type) {
case token.Character:
switch next.Data {
case 0x9, 0xa, 0xc, 0xd, ' ':
offset, tokens = offset+1, tokens[1:]
continue
}
}
return offset, tokens
}
} | pkg/asset/html/parser/parse.go | 0.6705 | 0.463809 | parse.go | starcoder |
package bstree
import (
"fmt"
"godev/basic"
)
// BSTree Binary Search Tree
// http://cslibrary.stanford.edu/110/BinaryTrees.html
type BSTree struct {
Root *Node
Comparator basic.Comparator
Diffidence func(a, b interface{}) interface{}
}
// NewBSTree create a nil BSTree
func NewBSTree() *BSTree {
return &BSTree{
Root: nil,
Comparator: nil,
}
}
// Node node of BSTree
type Node struct {
data interface{}
left, right *Node
}
// NewNode creates a Node from input data
func NewNode(data interface{}) *Node {
return &Node{
data: data,
left: nil,
right: nil,
}
}
func (bst *BSTree) lookup(node *Node, target interface{}) bool {
if node == nil {
return false
}
switch bst.Comparator(target, node.data) {
case 0:
return true
case -1:
return bst.lookup(node.left, target)
case 1:
return bst.lookup(node.right, target)
default:
return false
}
}
// Lookup returns true if target value stored inside the tree
func (bst *BSTree) Lookup(target interface{}) bool {
return bst.lookup(bst.Root, target)
}
func (bst *BSTree) insert(node *Node, data interface{}) *Node {
if node == nil {
return NewNode(data)
}
switch bst.Comparator(data, node.data) {
case -1, 0:
node.left = bst.insert(node.left, data)
case 1:
node.right = bst.insert(node.right, data)
}
return node
}
// Insert inserts data into the tree
func (bst *BSTree) Insert(data interface{}) {
bst.Root = bst.insert(bst.Root, data)
}
func (bst *BSTree) print(node *Node) {
if node == nil {
return
}
bst.print(node.left)
fmt.Printf("%+v ", node.data)
bst.print(node.right)
}
// Print prints the tree with values in increasing order
func (bst *BSTree) Print() {
bst.print(bst.Root)
fmt.Println()
}
// Empty returns true if the tree has no value inside (root is nil)
func (bst *BSTree) Empty() bool {
return bst.Root == nil
}
func (bst *BSTree) size(node *Node) int {
if node == nil {
return 0
}
return bst.size(node.left) + 1 + bst.size(node.right)
}
// Size returns the number of nodes inside the tree
func (bst *BSTree) Size() int {
return bst.size(bst.Root)
}
func (bst *BSTree) value(node *Node, dataSlice *[]interface{}) {
if node == nil {
return
}
bst.value(node.left, dataSlice)
*dataSlice = append(*dataSlice, node.data)
bst.value(node.right, dataSlice)
}
// Values returns values stored inside the tree in increasing order
func (bst *BSTree) Values() []interface{} {
if bst.Root == nil {
return nil
}
var dataSlice []interface{}
bst.value(bst.Root, &dataSlice)
return dataSlice
}
// Clear clears the tree by setting root to nil
func (bst *BSTree) Clear() {
bst.Root = nil
}
func (bst *BSTree) maxDepth(node *Node) int {
if node == nil {
return 0
}
lDepth := bst.maxDepth(node.left)
rDepth := bst.maxDepth(node.right)
if lDepth > rDepth {
return lDepth + 1
}
return rDepth + 1
}
// MaxDepth returns the tree height
func (bst *BSTree) MaxDepth() int {
return bst.maxDepth(bst.Root)
}
func (bst *BSTree) minValue(node *Node) interface{} {
currentNode := node
for currentNode.left != nil {
currentNode = currentNode.left
}
return currentNode.data
}
// MinValue returns the minimum value stored inside the tree
func (bst *BSTree) MinValue() interface{} {
return bst.minValue(bst.Root)
}
func (bst *BSTree) hasPathSum(node *Node, sum interface{}) bool {
if node == nil {
return sum == 0
}
sum = bst.Diffidence(sum, node.data)
return bst.hasPathSum(node.left, sum) || bst.hasPathSum(node.right, sum)
}
// HasPathSum returns true if there's one path to get the input sum by summing up all values along this path
func (bst *BSTree) HasPathSum(sum interface{}) bool {
if bst.Diffidence == nil {
panic("no Difference function for node data")
}
return bst.hasPathSum(bst.Root, sum)
}
func (bst *BSTree) printPaths(node *Node, path []interface{}) {
if node == nil {
return
}
path = append(path, node.data)
if node.left == nil && node.right == nil {
for _, p := range path {
fmt.Printf("%+v ", p)
}
fmt.Println()
} else {
bst.printPaths(node.left, path)
bst.printPaths(node.right, path)
}
}
// PrintPaths print all paths from root to leaf
func (bst *BSTree) PrintPaths() {
var paths []interface{}
bst.printPaths(bst.Root, paths)
}
func (bst *BSTree) mirror(node *Node) {
if node == nil {
return
}
bst.mirror(node.left)
bst.mirror(node.right)
// swap
node.left, node.right = node.right, node.left
}
// Mirror mirrors the tree (in-place change)
func (bst *BSTree) Mirror() {
bst.mirror(bst.Root)
}
func (bst *BSTree) doubleTree(node *Node) {
if node == nil {
return
}
bst.doubleTree(node.left)
bst.doubleTree(node.right)
oldLeft := node.left
node.left = NewNode(node.data)
node.left.left = oldLeft
}
// DoubleTree doubles the tree by duplicating nodes and insert them into the tree
func (bst *BSTree) DoubleTree() {
bst.doubleTree(bst.Root)
}
func (bst *BSTree) sameTree(nodeA, nodeB *Node) bool {
if nodeA == nil && nodeB == nil {
return true
} else if nodeA != nil && nodeB != nil {
return nodeA.data == nodeB.data && bst.sameTree(nodeA.left, nodeB.left) && bst.sameTree(nodeA.right, nodeB.right)
}
return false
}
// SameTree returns true if both trees are made of nodes with the same values
func (bst *BSTree) SameTree(bstB *BSTree) bool {
return bst.sameTree(bst.Root, bstB.Root)
}
// CountTrees counts how many structurally unique binary search trees which can store the given number of distinct values
func CountTrees(numKeys int) int {
if numKeys <= 1 {
return 1
}
sum, left, right := 0, 0, 0
for root := 0; root < numKeys; root++ {
// left tree node num
left = CountTrees(root)
// right tree node num
right = CountTrees(numKeys - 1 - root)
sum += left * right
}
return sum
}
func (bst *BSTree) isBST(node *Node, min, max interface{}) bool {
if node == nil {
return true
}
if bst.Comparator(node.data, min) < 0 || bst.Comparator(node.data, max) > 0 {
return false
}
return bst.isBST(node.left, min, node.data) && bst.isBST(node.right, node.data, max)
}
// IsBST returns true if the tree is binary search tree, its inputs should be the min and max values inside the tree
func (bst *BSTree) IsBST(min, max interface{}) bool {
return bst.isBST(bst.Root, min, max)
} | basic/datastructure/tree/bstree/bstree.go | 0.823044 | 0.50061 | bstree.go | starcoder |
package taskmaster
import (
"strconv"
"strings"
"syscall"
"time"
"github.com/go-ole/go-ole"
"github.com/rickb777/date/period"
)
// DayOfWeek is a day of the week.
type DayOfWeek uint16
const (
Sunday DayOfWeek = 1 << iota
Monday
Tuesday
Wednesday
Thursday
Friday
Saturday
AllDays DayOfWeek = (1 << 7) - 1
)
func (d DayOfWeek) String() string {
if d == 0 || d > AllDays {
return "Invalid day of week"
} else if d == AllDays {
return "All days of the week"
}
var buf strings.Builder
if Sunday&d == Sunday {
buf.WriteString("Sunday, ")
}
if Monday&d == Monday {
buf.WriteString("Monday, ")
}
if Tuesday&d == Tuesday {
buf.WriteString("Tuesday, ")
}
if Wednesday&d == Wednesday {
buf.WriteString("Wednesday, ")
}
if Thursday&d == Thursday {
buf.WriteString("Thursday, ")
}
if Friday&d == Friday {
buf.WriteString("Friday, ")
}
if Saturday&d == Saturday {
buf.WriteString("Saturday, ")
}
s := buf.String()
return s[:len(s)-2]
}
// DayInterval specifies if a task runs every day or every other day.
type DayInterval uint8
const (
EveryDay DayInterval = 1
EveryOtherDay DayInterval = 2
)
func (d DayInterval) String() string {
if d == EveryDay {
return "Every day"
} else if d == EveryOtherDay {
return "Every other day"
}
return "Invalid day interval"
}
// DayOfMonth is a day of a month.
type DayOfMonth uint32
const (
One DayOfMonth = 1 << iota
Two
Three
Four
Five
Six
Seven
Eight
Nine
Ten
Eleven
Twelve
Thirteen
Fourteen
Fifteen
Sixteen
Seventeen
Eighteen
Nineteen
Twenty
TwentyOne
TwentyTwo
TwentyThree
TwentyFour
TwentyFive
TwentySix
TwentySeven
TwentyEight
TwentyNine
Thirty
ThirtyOne
LastDayOfMonth
AllDaysOfMonth DayOfMonth = (1 << 31) - 1
)
func (d DayOfMonth) String() string {
if d == 0 || d > LastDayOfMonth {
return "Invalid day of month"
} else if d == AllDaysOfMonth {
return "All days of the month"
}
var buf strings.Builder
for i, j := DayOfMonth(1), uint(1); i < LastDayOfMonth; i, j = (1<<j+1)-1, j+1 {
if d&i == i {
buf.WriteString(strconv.FormatInt(int64(j), 10))
buf.WriteString(", ")
}
}
if d&LastDayOfMonth == LastDayOfMonth {
buf.WriteString("last day of month")
return buf.String()
}
s := buf.String()
return s[:len(s)-2]
}
// Month is one of the 12 months.
type Month uint16
const (
January Month = 1 << iota
February
March
April
May
June
July
August
September
October
November
December
AllMonths Month = (1 << 12) - 1
)
func (m Month) String() string {
if m == 0 || m > AllMonths {
return "Invalid month"
} else if m == AllMonths {
return "All months"
}
var buf strings.Builder
if m&January == January {
buf.WriteString("January, ")
}
if m&February == February {
buf.WriteString("February, ")
}
if m&March == March {
buf.WriteString("March, ")
}
if m&April == April {
buf.WriteString("April, ")
}
if m&May == May {
buf.WriteString("May, ")
}
if m&June == June {
buf.WriteString("June, ")
}
if m&July == July {
buf.WriteString("July, ")
}
if m&August == August {
buf.WriteString("August, ")
}
if m&September == September {
buf.WriteString("September, ")
}
if m&October == October {
buf.WriteString("October, ")
}
if m&November == November {
buf.WriteString("November, ")
}
if m&December == December {
buf.WriteString("December, ")
}
s := buf.String()
return s[:len(s)-2]
}
// Week specifies what week of the month a task will run on.
type Week uint8
const (
First Week = 1 << iota
Second
Third
Fourth
LastWeek
AllWeeks Week = (1 << 5) - 1
)
func (w Week) String() string {
if w == 0 || w > AllWeeks {
return "Invalid week of the month"
} else if w == AllWeeks {
return "All weeks of the month"
}
var buf strings.Builder
if First&w == First {
buf.WriteString("First, ")
}
if Second&w == Second {
buf.WriteString("Second, ")
}
if Third&w == Third {
buf.WriteString("Third, ")
}
if Fourth&w == Fourth {
buf.WriteString("Fourth, ")
}
if LastWeek&w == LastWeek {
buf.WriteString("LastWeek, ")
}
s := buf.String()
return s[:len(s)-2]
}
// WeekInterval specifies if a task runs every week or every other week.
type WeekInterval uint8
const (
EveryWeek WeekInterval = 1
EveryOtherWeek WeekInterval = 2
)
func (w WeekInterval) String() string {
if w == EveryWeek {
return "Every week"
} else if w == EveryOtherWeek {
return "Every other week"
}
return "Invalid week interval"
}
// TaskActionType specifies the type of a task action.
// https://docs.microsoft.com/en-us/windows/desktop/api/taskschd/ne-taskschd-task_action_type
type TaskActionType uint
const (
TASK_ACTION_EXEC TaskActionType = 0
TASK_ACTION_COM_HANDLER TaskActionType = 5
TASK_ACTION_SEND_EMAIL TaskActionType = 6
TASK_ACTION_SHOW_MESSAGE TaskActionType = 7
)
func (t TaskActionType) String() string {
switch t {
case TASK_ACTION_EXEC:
return "Exec"
case TASK_ACTION_COM_HANDLER:
return "COM Handler"
case TASK_ACTION_SEND_EMAIL:
return "Send Email"
case TASK_ACTION_SHOW_MESSAGE:
return "Show Message"
default:
return ""
}
}
// TaskCompatibility specifies the compatibility of a registered task.
// https://docs.microsoft.com/en-us/windows/desktop/api/taskschd/ne-taskschd-task_compatibility
type TaskCompatibility uint
const (
TASK_COMPATIBILITY_AT TaskCompatibility = iota
TASK_COMPATIBILITY_V1
TASK_COMPATIBILITY_V2
TASK_COMPATIBILITY_V2_1
TASK_COMPATIBILITY_V2_2
TASK_COMPATIBILITY_V2_3
TASK_COMPATIBILITY_V2_4
)
func (c TaskCompatibility) String() string {
switch c {
case TASK_COMPATIBILITY_AT:
return "AT"
case TASK_COMPATIBILITY_V1:
return "v1.0"
case TASK_COMPATIBILITY_V2:
return "v2.0"
case TASK_COMPATIBILITY_V2_1:
return "v2.1"
case TASK_COMPATIBILITY_V2_2:
return "v2.2"
case TASK_COMPATIBILITY_V2_3:
return "v2.3"
case TASK_COMPATIBILITY_V2_4:
return "v2.4"
default:
return ""
}
}
// TaskCreationFlags specifies how a task will be created.
// https://docs.microsoft.com/en-us/windows/desktop/api/taskschd/ne-taskschd-task_creation
type TaskCreationFlags uint
const (
TASK_VALIDATE_ONLY TaskCreationFlags = 0x01
TASK_CREATE TaskCreationFlags = 0x02
TASK_UPDATE TaskCreationFlags = 0x04
TASK_CREATE_OR_UPDATE TaskCreationFlags = 0x06
TASK_DISABLE TaskCreationFlags = 0x08
TASK_DONT_ADD_PRINCIPAL_ACE TaskCreationFlags = 0x10
TASK_IGNORE_REGISTRATION_TRIGGERS TaskCreationFlags = 0x20
)
// TaskEnumFlags specifies how tasks will be enumerated.
// https://docs.microsoft.com/en-us/windows/desktop/api/taskschd/ne-taskschd-task_enum_flags
type TaskEnumFlags uint
const (
TASK_ENUM_HIDDEN TaskEnumFlags = 1 // enumerate all tasks, including tasks that are hidden
)
// TaskInstancesPolicy specifies what the Task Scheduler service will do when
// multiple instances of a task are triggered or operating at once.
// https://docs.microsoft.com/en-us/windows/desktop/api/taskschd/ne-taskschd-task_instances_policy
type TaskInstancesPolicy uint
const (
TASK_INSTANCES_PARALLEL TaskInstancesPolicy = iota // start new instance while an existing instance is running
TASK_INSTANCES_QUEUE // start a new instance of the task after all other instances of the task are complete
TASK_INSTANCES_IGNORE_NEW // do not start a new instance if an existing instance of the task is running
TASK_INSTANCES_STOP_EXISTING // stop an existing instance of the task before it starts a new instance
)
func (t TaskInstancesPolicy) String() string {
switch t {
case TASK_INSTANCES_PARALLEL:
return "Run Parallel"
case TASK_INSTANCES_QUEUE:
return "Queue Instances"
case TASK_INSTANCES_IGNORE_NEW:
return "Ignore New"
case TASK_INSTANCES_STOP_EXISTING:
return "Stop Existing"
default:
return ""
}
}
// TaskLogonType specifies how a registered task will authenticate when it executes.
// https://docs.microsoft.com/en-us/windows/desktop/api/taskschd/ne-taskschd-task_logon_type
type TaskLogonType uint
const (
TASK_LOGON_NONE TaskLogonType = iota // the logon method is not specified. Used for non-NT credentials
TASK_LOGON_PASSWORD // use a password for logging on the user. The password must be supplied at registration time
TASK_LOGON_S4U // the service will log the user on using Service For User (S4U), and the task will run in a non-interactive desktop. When an S4U logon is used, no password is stored by the system and there is no access to either the network or to encrypted files
TASK_LOGON_INTERACTIVE_TOKEN // user must already be logged on. The task will be run only in an existing interactive session
TASK_LOGON_GROUP // group activation
TASK_LOGON_SERVICE_ACCOUNT // indicates that a Local System, Local Service, or Network Service account is being used as a security context to run the task
TASK_LOGON_INTERACTIVE_TOKEN_OR_PASSWORD // first use the interactive token. If the user is not logged on (no interactive token is available), then the password is used. The password must be specified when a task is registered. This flag is not recommended for new tasks because it is less reliable than TASK_LOGON_PASSWORD
)
func (t TaskLogonType) String() string {
switch t {
case TASK_LOGON_NONE:
return "None"
case TASK_LOGON_PASSWORD:
return "Password"
case TASK_LOGON_S4U:
return "S4u"
case TASK_LOGON_INTERACTIVE_TOKEN:
return "Interactive Token"
case TASK_LOGON_GROUP:
return "Group"
case TASK_LOGON_SERVICE_ACCOUNT:
return "Service Account"
case TASK_LOGON_INTERACTIVE_TOKEN_OR_PASSWORD:
return "Interactive Token or Password"
default:
return ""
}
}
// TaskRunFlags specifies how a task will be executed.
// https://docs.microsoft.com/en-us/windows/desktop/api/taskschd/ne-taskschd-task_run_flags
type TaskRunFlags uint
const (
TASK_RUN_NO_FLAGS TaskRunFlags = iota // the task is run with all flags ignored
TASK_RUN_AS_SELF // the task is run as the user who is calling the Run method
TASK_RUN_IGNORE_CONSTRAINTS // the task is run regardless of constraints such as "do not run on batteries" or "run only if idle"
TASK_RUN_USE_SESSION_ID // the task is run using a terminal server session identifier
TASK_RUN_USER_SID // the task is run using a security identifier
)
// TaskRunLevel specifies whether the task will be run with full permissions or not.
// https://docs.microsoft.com/en-us/windows/desktop/api/taskschd/ne-taskschd-task_runlevel_type
type TaskRunLevel uint
const (
TASK_RUNLEVEL_LUA TaskRunLevel = iota // task will be run with the least privileges
TASK_RUNLEVEL_HIGHEST // task will be run with the highest privileges
)
func (t TaskRunLevel) String() string {
switch t {
case TASK_RUNLEVEL_LUA:
return "Least"
case TASK_RUNLEVEL_HIGHEST:
return "Highest"
default:
return ""
}
}
// TaskSessionStateChangeType specifies the type of session state change that a
// SessionStateChange trigger will trigger on.
// https://docs.microsoft.com/en-us/windows/desktop/api/taskschd/ne-taskschd-task_session_state_change_type
type TaskSessionStateChangeType uint
const (
TASK_CONSOLE_CONNECT TaskSessionStateChangeType = 1 // Terminal Server console connection state change. For example, when you connect to a user session on the local computer by switching users on the computer
TASK_CONSOLE_DISCONNECT TaskSessionStateChangeType = 2 // Terminal Server console disconnection state change. For example, when you disconnect to a user session on the local computer by switching users on the computer
TASK_REMOTE_CONNECT TaskSessionStateChangeType = 3 // Terminal Server remote connection state change. For example, when a user connects to a user session by using the Remote Desktop Connection program from a remote computer
TASK_REMOTE_DISCONNECT TaskSessionStateChangeType = 4 // Terminal Server remote disconnection state change. For example, when a user disconnects from a user session while using the Remote Desktop Connection program from a remote computer
TASK_SESSION_LOCK TaskSessionStateChangeType = 7 // Terminal Server session locked state change. For example, this state change causes the task to run when the computer is locked
TASK_SESSION_UNLOCK TaskSessionStateChangeType = 8 // Terminal Server session unlocked state change. For example, this state change causes the task to run when the computer is unlocked
)
func (t TaskSessionStateChangeType) String() string {
switch t {
case TASK_CONSOLE_CONNECT:
return "Console Connect"
case TASK_CONSOLE_DISCONNECT:
return "Console Disconnect"
case TASK_REMOTE_CONNECT:
return "Remote Connect"
case TASK_REMOTE_DISCONNECT:
return "Remote Disconnect"
case TASK_SESSION_LOCK:
return "Session Lock"
case TASK_SESSION_UNLOCK:
return "Session Unlock"
default:
return ""
}
}
// TaskState specifies the state of a running or registered task.
// https://docs.microsoft.com/en-us/windows/desktop/api/taskschd/ne-taskschd-task_state
type TaskState uint
const (
TASK_STATE_UNKNOWN TaskState = iota // the state of the task is unknown
TASK_STATE_DISABLED // the task is registered but is disabled and no instances of the task are queued or running. The task cannot be run until it is enabled
TASK_STATE_QUEUED // instances of the task are queued
TASK_STATE_READY // the task is ready to be executed, but no instances are queued or running
TASK_STATE_RUNNING // one or more instances of the task is running
)
func (t TaskState) String() string {
switch t {
case TASK_STATE_UNKNOWN:
return "Unknown"
case TASK_STATE_DISABLED:
return "Disabled"
case TASK_STATE_QUEUED:
return "Queued"
case TASK_STATE_READY:
return "Ready"
case TASK_STATE_RUNNING:
return "Running"
default:
return ""
}
}
// TaskTriggerType specifies the type of a task trigger.
// https://docs.microsoft.com/en-us/windows/desktop/api/taskschd/ne-taskschd-task_trigger_type2
type TaskTriggerType uint
const (
TASK_TRIGGER_EVENT TaskTriggerType = 0
TASK_TRIGGER_TIME TaskTriggerType = 1
TASK_TRIGGER_DAILY TaskTriggerType = 2
TASK_TRIGGER_WEEKLY TaskTriggerType = 3
TASK_TRIGGER_MONTHLY TaskTriggerType = 4
TASK_TRIGGER_MONTHLYDOW TaskTriggerType = 5
TASK_TRIGGER_IDLE TaskTriggerType = 6
TASK_TRIGGER_REGISTRATION TaskTriggerType = 7
TASK_TRIGGER_BOOT TaskTriggerType = 8
TASK_TRIGGER_LOGON TaskTriggerType = 9
TASK_TRIGGER_SESSION_STATE_CHANGE TaskTriggerType = 11
TASK_TRIGGER_CUSTOM_TRIGGER_01 TaskTriggerType = 12
)
func (t TaskTriggerType) String() string {
switch t {
case TASK_TRIGGER_EVENT:
return "Event"
case TASK_TRIGGER_TIME:
return "Time"
case TASK_TRIGGER_DAILY:
return "Daily"
case TASK_TRIGGER_WEEKLY:
return "Weekly"
case TASK_TRIGGER_MONTHLY:
return "Monthly"
case TASK_TRIGGER_MONTHLYDOW:
return "Monthly Day of the Week"
case TASK_TRIGGER_IDLE:
return "Idle"
case TASK_TRIGGER_REGISTRATION:
return "registration"
case TASK_TRIGGER_BOOT:
return "Boot"
case TASK_TRIGGER_LOGON:
return "Logon"
case TASK_TRIGGER_SESSION_STATE_CHANGE:
return "Session State Change"
case TASK_TRIGGER_CUSTOM_TRIGGER_01:
return "Custom"
default:
return ""
}
}
type TaskResult uint32
const (
SCHED_S_SUCCESS TaskResult = 0x0
SCHED_S_TASK_READY TaskResult = iota + 0x00041300
SCHED_S_TASK_RUNNING
SCHED_S_TASK_DISABLED
SCHED_S_TASK_HAS_NOT_RUN
SCHED_S_TASK_NO_MORE_RUNS
SCHED_S_TASK_NOT_SCHEDULED
SCHED_S_TASK_TERMINATED
SCHED_S_TASK_NO_VALID_TRIGGERS
SCHED_S_EVENT_TRIGGER
SCHED_S_SOME_TRIGGERS_FAILED TaskResult = 0x0004131B
SCHED_S_BATCH_LOGON_PROBLEM TaskResult = 0x0004131C
SCHED_S_TASK_QUEUED TaskResult = 0x00041325
)
func (r TaskResult) String() string {
switch r {
case SCHED_S_SUCCESS:
return "Completed successfully"
case SCHED_S_TASK_READY:
return "Ready"
case SCHED_S_TASK_RUNNING:
return "Currently running"
case SCHED_S_TASK_DISABLED:
return "Disabled"
case SCHED_S_TASK_HAS_NOT_RUN:
return "Has not been run yet"
case SCHED_S_TASK_NO_MORE_RUNS:
return "No more runs scheduled"
case SCHED_S_TASK_NOT_SCHEDULED:
return "One or more of the properties that are needed to run this task on a schedule have not been set"
case SCHED_S_TASK_TERMINATED:
return "Terminated by user"
case SCHED_S_TASK_NO_VALID_TRIGGERS:
return "Either the task has no triggers or the existing triggers are disabled or not set"
case SCHED_S_EVENT_TRIGGER:
return "Event triggers do not have set run times"
case SCHED_S_SOME_TRIGGERS_FAILED:
return "Not all specified triggers will start the task"
case SCHED_S_BATCH_LOGON_PROBLEM:
return "May fail to start unless batch logon privilege is enabled for the task principal"
case SCHED_S_TASK_QUEUED:
return "Queued"
default:
return syscall.Errno(r).Error()
}
}
type TaskService struct {
taskServiceObj *ole.IDispatch
rootFolderObj *ole.IDispatch
isInitialized bool
isConnected bool
connectedDomain string
connectedComputerName string
connectedUser string
}
type TaskFolder struct {
isReleased bool
Name string
Path string
SubFolders []*TaskFolder
RegisteredTasks RegisteredTaskCollection
}
// RunningTask is a task that is currently running.
// https://docs.microsoft.com/en-us/windows/desktop/api/taskschd/nn-taskschd-irunningtask
type RunningTask struct {
taskObj *ole.IDispatch
isReleased bool
CurrentAction string // the name of the current action that the running task is performing
EnginePID uint // the process ID for the engine (process) which is running the task
InstanceGUID string // the GUID identifier for this instance of the task
Name string // the name of the task
Path string // the path to where the task is stored
State TaskState // an identifier for the state of the running task
}
// RegisteredTask is a task that is registered in the Task Scheduler database.
// https://docs.microsoft.com/en-us/windows/desktop/api/taskschd/nn-taskschd-iregisteredtask
type RegisteredTask struct {
taskObj *ole.IDispatch
isReleased bool
Name string // the name of the registered task
Path string // the path to where the registered task is stored
Definition Definition
Enabled bool
State TaskState // the operational state of the registered task
MissedRuns uint // the number of times the registered task has missed a scheduled run
NextRunTime time.Time // the time when the registered task is next scheduled to run
LastRunTime time.Time // the time the registered task was last run
LastTaskResult TaskResult // the results that were returned the last time the registered task was run
}
// Definition defines all the components of a task, such as the task settings, triggers, actions, and registration information
// https://docs.microsoft.com/en-us/windows/desktop/api/taskschd/nn-taskschd-itaskdefinition
type Definition struct {
Actions []Action
Context string // specifies the security context under which the actions of the task are performed
Data string // the data that is associated with the task
Principal Principal
RegistrationInfo RegistrationInfo
Settings TaskSettings
Triggers []Trigger
XMLText string // the XML-formatted definition of the task
}
type Action interface {
GetID() string
GetType() TaskActionType
}
// ExecAction is an action that performs a command-line operation. The args
// field can have up to 32 $(ArgX) values, such as '/c $(Arg0) $(Arg1)'.
// This will allow the arguments to be dynamically entered when the task is run.
// https://docs.microsoft.com/en-us/windows/desktop/api/taskschd/nn-taskschd-iexecaction
type ExecAction struct {
ID string
Path string
Args string
WorkingDir string
}
// ComHandlerAction is an action that fires a COM handler. Can only be used if TASK_COMPATIBILITY_V2 or above is set.
// The clisd parameter is the CLSID of the COM object that will get instantiated when the action executes, and the
// data parameter is the arguments passed to the COM object.
// https://docs.microsoft.com/en-us/windows/desktop/api/taskschd/nn-taskschd-icomhandleraction
type ComHandlerAction struct {
ID string
ClassID string
Data string
}
// Principal provides security credentials that define the security context for the tasks that are associated with it.
// https://docs.microsoft.com/en-us/windows/desktop/api/taskschd/nn-taskschd-iprincipal
type Principal struct {
Name string // the name of the principal
GroupID string // the identifier of the user group that is required to run the tasks
ID string // the identifier of the principal
LogonType TaskLogonType // the security logon method that is required to run the tasks
RunLevel TaskRunLevel // the identifier that is used to specify the privilege level that is required to run the tasks
UserID string // the user identifier that is required to run the tasks
}
// RegistrationInfo provides the administrative information that can be used to describe the task
// https://docs.microsoft.com/en-us/windows/desktop/api/taskschd/nn-taskschd-iregistrationinfo
type RegistrationInfo struct {
Author string
Date time.Time
Description string
Documentation string
SecurityDescriptor string
Source string
URI string
Version string
}
// TaskSettings provides the settings that the Task Scheduler service uses to perform the task
// https://docs.microsoft.com/en-us/windows/desktop/api/taskschd/nn-taskschd-itasksettings
type TaskSettings struct {
AllowDemandStart bool // indicates that the task can be started by using either the Run command or the Context menu
AllowHardTerminate bool // indicates that the task may be terminated by the Task Scheduler service using TerminateProcess
Compatibility TaskCompatibility // indicates which version of Task Scheduler a task is compatible with
DeleteExpiredTaskAfter string // the amount of time that the Task Scheduler will wait before deleting the task after it expires
DontStartOnBatteries bool // indicates that the task will not be started if the computer is running on batteries
Enabled bool // indicates that the task is enabled
TimeLimit period.Period // the amount of time that is allowed to complete the task
Hidden bool // indicates that the task will not be visible in the UI
IdleSettings
MultipleInstances TaskInstancesPolicy // defines how the Task Scheduler deals with multiple instances of the task
NetworkSettings
Priority uint // the priority level of the task, ranging from 0 - 10, where 0 is the highest priority, and 10 is the lowest. Only applies to ComHandler, Email, and MessageBox actions
RestartCount uint // the number of times that the Task Scheduler will attempt to restart the task
RestartInterval period.Period // specifies how long the Task Scheduler will attempt to restart the task
RunOnlyIfIdle bool // indicates that the Task Scheduler will run the task only if the computer is in an idle condition
RunOnlyIfNetworkAvailable bool // indicates that the Task Scheduler will run the task only when a network is available
StartWhenAvailable bool // indicates that the Task Scheduler can start the task at any time after its scheduled time has passed
StopIfGoingOnBatteries bool // indicates that the task will be stopped if the computer is going onto batteries
WakeToRun bool // indicates that the Task Scheduler will wake the computer when it is time to run the task, and keep the computer awake until the task is completed
}
// IdleSettings specifies how the Task Scheduler performs tasks when the computer is in an idle condition.
// https://docs.microsoft.com/en-us/windows/desktop/api/taskschd/nn-taskschd-iidlesettings
type IdleSettings struct {
IdleDuration period.Period // the amount of time that the computer must be in an idle state before the task is run
RestartOnIdle bool // whether the task is restarted when the computer cycles into an idle condition more than once
StopOnIdleEnd bool // indicates that the Task Scheduler will terminate the task if the idle condition ends before the task is completed
WaitTimeout period.Period // the amount of time that the Task Scheduler will wait for an idle condition to occur
}
// NetworkSettings provides the settings that the Task Scheduler service uses to obtain a network profile.
// https://docs.microsoft.com/en-us/windows/desktop/api/taskschd/nn-taskschd-inetworksettings
type NetworkSettings struct {
ID string // a GUID value that identifies a network profile
Name string // the name of a network profile
}
type Trigger interface {
GetEnabled() bool
GetEndBoundary() time.Time
GetExecutionTimeLimit() period.Period
GetID() string
GetRepetitionDuration() period.Period
GetRepetitionInterval() period.Period
GetStartBoundary() time.Time
GetStopAtDurationEnd() bool
GetType() TaskTriggerType
}
// TaskTrigger provides the common properties that are inherited by all trigger objects.
// https://docs.microsoft.com/en-us/windows/desktop/api/taskschd/nn-taskschd-itrigger
type TaskTrigger struct {
Enabled bool // indicates whether the trigger is enabled
EndBoundary time.Time // the date and time when the trigger is deactivated
ExecutionTimeLimit period.Period // the maximum amount of time that the task launched by this trigger is allowed to run
ID string // the identifier for the trigger
RepetitionPattern
StartBoundary time.Time // the date and time when the trigger is activated
}
// RepetitionPattern defines how often the task is run and how long the repetition pattern is repeated after the task is started.
// https://docs.microsoft.com/en-us/windows/desktop/api/taskschd/nn-taskschd-irepetitionpattern
type RepetitionPattern struct {
RepetitionDuration period.Period // how long the pattern is repeated
RepetitionInterval period.Period // the amount of time between each restart of the task. Required if RepetitionDuration is specified. Minimum time is one minute
StopAtDurationEnd bool // indicates if a running instance of the task is stopped at the end of the repetition pattern duration
}
// BootTrigger triggers the task when the computer boots. Only Administrators can create tasks with a BootTrigger.
// https://docs.microsoft.com/en-us/windows/desktop/api/taskschd/nn-taskschd-iboottrigger
type BootTrigger struct {
TaskTrigger
Delay period.Period // indicates the amount of time between when the system is booted and when the task is started
}
// DailyTrigger triggers the task on a daily schedule. For example, the task starts at a specific time every day, every other day, or every third day. The time of day that the task is started is set by StartBoundary, which must be set.
// https://docs.microsoft.com/en-us/windows/desktop/api/taskschd/nn-taskschd-idailytrigger
type DailyTrigger struct {
TaskTrigger
DayInterval DayInterval // the interval between the days in the schedule
RandomDelay period.Period // a delay time that is randomly added to the start time of the trigger
}
// EventTrigger triggers the task when a specific event occurs. A maximum of 500 tasks with event subscriptions can be created.
// https://docs.microsoft.com/en-us/windows/desktop/api/taskschd/nn-taskschd-ieventtrigger
type EventTrigger struct {
TaskTrigger
Delay period.Period // indicates the amount of time between when the event occurs and when the task is started
Subscription string // a query string that identifies the event that fires the trigger
ValueQueries map[string]string // a collection of named XPath queries. Each query in the collection is applied to the last matching event XML returned from the subscription query
}
// IdleTrigger triggers the task when the computer goes into an idle state. An IdleTrigger will only trigger a task action if the computer goes into an idle state after the start boundary of the trigger
// https://docs.microsoft.com/en-us/windows/desktop/api/taskschd/nn-taskschd-iidletrigger
type IdleTrigger struct {
TaskTrigger
}
// LogonTrigger triggers the task when a specific user logs on. When the Task Scheduler service starts, all logged-on users are enumerated and any tasks registered with logon triggers that match the logged on user are run.
// https://docs.microsoft.com/en-us/windows/desktop/api/taskschd/nn-taskschd-ilogontrigger
type LogonTrigger struct {
TaskTrigger
Delay period.Period // indicates the amount of time between when the user logs on and when the task is started
UserID string // the identifier of the user. If left empty, the trigger will fire when any user logs on
}
// MonthlyDOWTrigger triggers the task on a monthly day-of-week schedule. For example, the task starts on a specific days of the week, weeks of the month, and months of the year. The time of day that the task is started is set by StartBoundary, which must be set.
// https://docs.microsoft.com/en-us/windows/desktop/api/taskschd/nn-taskschd-imonthlydowtrigger
type MonthlyDOWTrigger struct {
TaskTrigger
DaysOfWeek DayOfWeek // the days of the week during which the task runs
MonthsOfYear Month // the months of the year during which the task runs
RandomDelay period.Period // a delay time that is randomly added to the start time of the trigger
RunOnLastWeekOfMonth bool // indicates that the task runs on the last week of the month
WeeksOfMonth Week // the weeks of the month during which the task runs
}
// MonthlyTrigger triggers the task on a monthly schedule. For example, the task starts on specific days of specific months.
// The time of day that the task is started is set by StartBoundary, which must be set.
// https://docs.microsoft.com/en-us/windows/desktop/api/taskschd/nn-taskschd-imonthlytrigger
type MonthlyTrigger struct {
TaskTrigger
DaysOfMonth DayOfMonth // the days of the month during which the task runs
MonthsOfYear Month // the months of the year during which the task runs
RandomDelay period.Period // a delay time that is randomly added to the start time of the trigger
RunOnLastWeekOfMonth bool // indicates that the task runs on the last week of the month
}
// RegistrationTrigger triggers the task when the task is registered.
// https://docs.microsoft.com/en-us/windows/desktop/api/taskschd/nn-taskschd-iregistrationtrigger
type RegistrationTrigger struct {
TaskTrigger
Delay period.Period // the amount of time between when the task is registered and when the task is started
}
// SessionStateChangeTrigger triggers the task when a specific user session state changes.
// https://docs.microsoft.com/en-us/windows/desktop/api/taskschd/nn-taskschd-isessionstatechangetrigger
type SessionStateChangeTrigger struct {
TaskTrigger
Delay period.Period // indicates how long of a delay takes place before a task is started after a Terminal Server session state change is detected
StateChange TaskSessionStateChangeType // the kind of Terminal Server session change that would trigger a task launch
UserId string // the user for the Terminal Server session. When a session state change is detected for this user, a task is started
}
// TimeTrigger triggers the task at a specific time of day. StartBoundary determines when the trigger fires.
// https://docs.microsoft.com/en-us/windows/desktop/api/taskschd/nn-taskschd-itimetrigger
type TimeTrigger struct {
TaskTrigger
RandomDelay period.Period // a delay time that is randomly added to the start time of the trigger
}
// WeeklyTrigger triggers the task on a weekly schedule. The time of day that the task is started is set by StartBoundary, which must be set.
// https://docs.microsoft.com/en-us/windows/desktop/api/taskschd/nn-taskschd-iweeklytrigger
type WeeklyTrigger struct {
TaskTrigger
DaysOfWeek DayOfWeek // the days of the week in which the task runs
RandomDelay period.Period // a delay time that is randomly added to the start time of the trigger
WeekInterval WeekInterval // the interval between the weeks in the schedule
}
type CustomTrigger struct {
TaskTrigger
}
func (t TaskService) IsConnected() bool {
return t.isConnected
}
func (t TaskService) GetConnectedDomain() string {
return t.connectedDomain
}
func (t TaskService) GetConnectedComputerName() string {
return t.connectedComputerName
}
func (t TaskService) GetConnectedUser() string {
return t.connectedUser
}
func (e ExecAction) GetID() string {
return e.ID
}
func (ExecAction) GetType() TaskActionType {
return TASK_ACTION_EXEC
}
func (c ComHandlerAction) GetID() string {
return c.ID
}
func (ComHandlerAction) GetType() TaskActionType {
return TASK_ACTION_COM_HANDLER
}
func (t TaskTrigger) GetRepetitionDuration() period.Period {
return t.RepetitionDuration
}
func (t TaskTrigger) GetEnabled() bool {
return t.Enabled
}
func (t TaskTrigger) GetEndBoundary() time.Time {
return t.EndBoundary
}
func (t TaskTrigger) GetExecutionTimeLimit() period.Period {
return t.ExecutionTimeLimit
}
func (t TaskTrigger) GetID() string {
return t.ID
}
func (t TaskTrigger) GetRepetitionInterval() period.Period {
return t.RepetitionInterval
}
func (t TaskTrigger) GetStartBoundary() time.Time {
return t.StartBoundary
}
func (t TaskTrigger) GetStopAtDurationEnd() bool {
return t.StopAtDurationEnd
}
func (BootTrigger) GetType() TaskTriggerType {
return TASK_TRIGGER_BOOT
}
func (DailyTrigger) GetType() TaskTriggerType {
return TASK_TRIGGER_DAILY
}
func (EventTrigger) GetType() TaskTriggerType {
return TASK_TRIGGER_EVENT
}
func (IdleTrigger) GetType() TaskTriggerType {
return TASK_TRIGGER_IDLE
}
func (LogonTrigger) GetType() TaskTriggerType {
return TASK_TRIGGER_LOGON
}
func (MonthlyDOWTrigger) GetType() TaskTriggerType {
return TASK_TRIGGER_MONTHLYDOW
}
func (MonthlyTrigger) GetType() TaskTriggerType {
return TASK_TRIGGER_MONTHLY
}
func (RegistrationTrigger) GetType() TaskTriggerType {
return TASK_TRIGGER_REGISTRATION
}
func (SessionStateChangeTrigger) GetType() TaskTriggerType {
return TASK_TRIGGER_SESSION_STATE_CHANGE
}
func (TimeTrigger) GetType() TaskTriggerType {
return TASK_TRIGGER_TIME
}
func (WeeklyTrigger) GetType() TaskTriggerType {
return TASK_TRIGGER_WEEKLY
}
func (CustomTrigger) GetType() TaskTriggerType {
return TASK_TRIGGER_CUSTOM_TRIGGER_01
} | types.go | 0.53048 | 0.406509 | types.go | starcoder |
package lexer
import (
"github.com/yourfavoritedev/golang-interpreter/token"
)
// Lexer converts a string input to produce tokens for the Monkey language.
// It always keeps track of the current position, the next readable position and
// the current character under examination. These tokens will be parsed by
// the parser, which constructs the abstract syntax-tree (AST).
type Lexer struct {
input string
position int // current position in input (points to the current char)
readPosition int // current reading position in input (points to the char that will be read next)
ch byte // current char under examination
}
// readChar finds the next character in the input and then advances our position in the input
func (l *Lexer) readChar() {
if l.readPosition >= len(l.input) {
l.ch = 0 // 0 is the ASCII code for the "NUL" character
} else {
l.ch = l.input[l.readPosition]
}
l.position = l.readPosition
l.readPosition += 1
}
// readNumber reads a number and advances the lexer position until it encounters a non-digit character
func (l *Lexer) readNumber() string {
position := l.position
for isDigit(l.ch) {
l.readChar()
}
return l.input[position:l.position]
}
// readIdentifier reads an identifer and advances the lexer position until it encounters a non-letter character
func (l *Lexer) readIdentifier() string {
position := l.position
for isLetter(l.ch) {
l.readChar()
}
return l.input[position:l.position]
}
// peekChar finds the next character in the input. It does not increment the position and readPosition of the lexer.
func (l *Lexer) peekChar() byte {
if l.readPosition >= len(l.input) {
return 0
} else {
return l.input[l.readPosition]
}
}
// skipWhitespace will skip the current character and advance the lexer's position if it is a whitespace
func (l *Lexer) skipWhitespace() {
for l.ch == ' ' || l.ch == '\t' || l.ch == '\n' || l.ch == '\r' {
l.readChar()
}
}
// readString constructs a string literal using the input between the current character '"' and the
// closing '"' character. It advances the lexer's position until it encounters the closing '"' character or EOF.
func (l *Lexer) readString() string {
position := l.position + 1
for {
l.readChar()
if l.ch == '"' || l.ch == 0 {
break
}
}
return l.input[position:l.position]
}
// NextToken looks at the current character under examination and returns a Token depending on which character it is.
func (l *Lexer) NextToken() token.Token {
var tok token.Token
l.skipWhitespace()
switch l.ch {
case '=':
if l.peekChar() == '=' {
ch := l.ch
l.readChar()
literal := string(ch) + string(l.ch)
tok = token.Token{Type: token.EQ, Literal: literal}
} else {
tok = newToken(token.ASSIGN, l.ch)
}
case '+':
tok = newToken(token.PLUS, l.ch)
case '-':
tok = newToken(token.MINUS, l.ch)
case '!':
if l.peekChar() == '=' {
ch := l.ch
l.readChar()
literal := string(ch) + string(l.ch)
tok = token.Token{Type: token.NOT_EQ, Literal: literal}
} else {
tok = newToken(token.BANG, l.ch)
}
case '*':
tok = newToken(token.ASTERISK, l.ch)
case '/':
tok = newToken(token.SLASH, l.ch)
case '<':
tok = newToken(token.LT, l.ch)
case '>':
tok = newToken(token.GT, l.ch)
case ',':
tok = newToken(token.COMMA, l.ch)
case ';':
tok = newToken(token.SEMICOLON, l.ch)
case '(':
tok = newToken(token.LPAREN, l.ch)
case ')':
tok = newToken(token.RPAREN, l.ch)
case '{':
tok = newToken(token.LBRACE, l.ch)
case '}':
tok = newToken(token.RBRACE, l.ch)
case '"':
tok.Type = token.STRING
tok.Literal = l.readString()
case '[':
tok = newToken(token.LBRACKET, l.ch)
case ']':
tok = newToken(token.RBRACKET, l.ch)
case ':':
tok = newToken(token.COLON, l.ch)
case 0:
tok.Literal = ""
tok.Type = token.EOF
default:
if isLetter(l.ch) {
tok.Literal = l.readIdentifier()
tok.Type = token.LookupIdent(tok.Literal)
return tok
} else if isDigit(l.ch) {
tok.Type = token.INT
tok.Literal = l.readNumber()
return tok
} else {
tok = newToken(token.ILLEGAL, l.ch)
}
}
// advance position of input after reading character
l.readChar()
return tok
}
// isLetter checks whether the given character is a letter
func isLetter(ch byte) bool {
return 'a' <= ch && ch <= 'z' || 'A' <= ch && ch <= 'Z' || ch == '_'
}
// isDigit checks whether the given character is a digit
func isDigit(ch byte) bool {
return '0' <= ch && ch <= '9'
}
// newToken creates a new Token with the given TokenType and character
func newToken(tokenType token.TokenType, ch byte) token.Token {
return token.Token{
Type: tokenType,
Literal: string(ch),
}
}
// New creates a new Lexer for a given input
// It calls readChar a single time to initialize the first char to be examined,
// then sets the position and the next readPosition for the lexer
func New(input string) *Lexer {
l := &Lexer{input: input}
l.readChar()
return l
} | lexer/lexer.go | 0.661048 | 0.459864 | lexer.go | starcoder |
package geomtest
import (
"fmt"
"reflect"
"github.com/adamcolton/geom/calc/cmpr"
"github.com/adamcolton/geom/geomerr"
"github.com/stretchr/testify/assert"
)
type tHelper interface {
Helper()
}
// Equal calls AssertEqual with the default value of Small. If there is an error
// it is passed into t.Error. The return bool will be true if the values were
// equal.
func Equal(t assert.TestingT, expected, actual interface{}, msg ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
}
return EqualInDelta(t, expected, actual, Small, msg...)
}
var equalType = reflect.TypeOf((*AssertEqualizer)(nil)).Elem()
// EqualInDelta calls AssertEqual. If there is an error it is passed into
// t.Error. The return bool will be true if the values were equal.
func EqualInDelta(t assert.TestingT, expected, actual interface{}, delta cmpr.Tolerance, msg ...interface{}) bool {
if h, ok := t.(tHelper); ok {
h.Helper()
}
err := AssertEqual(expected, actual, delta)
if err == nil {
return true
}
if len(msg) > 0 {
t.Errorf("%s: %s", err.Error(), Message(msg...))
} else {
t.Errorf("%s", err.Error())
}
return false
}
// AssertEqual can compare anything that implements geomtest.AssertEqualizer.
// There is also logic to handle comparing float64 values Any two slices whose
// elements can be compared with Equal can be compared. The provided delta value
// will be passed to anything that implements AssertEqualizer. If the equality
// check fails, an error is returned.
func AssertEqual(expected, actual interface{}, delta cmpr.Tolerance) error {
ev := reflect.ValueOf(expected)
if ev.Kind() == reflect.Slice {
av := reflect.ValueOf(actual)
if av.Kind() != reflect.Slice {
return geomerr.TypeMismatch(expected, actual)
}
return geomerr.NewSliceErrs(ev.Len(), av.Len(), func(i int) error {
return AssertEqual(ev.Index(i).Interface(), av.Index(i).Interface(), delta)
})
}
if eq, ok := expected.(AssertEqualizer); ok {
return eq.AssertEqual(actual, delta)
} else if ef, ok := expected.(float64); ok {
if err := geomerr.NewTypeMismatch(expected, actual); err != nil {
return err
}
af := actual.(float64)
return geomerr.NewNotEqual(delta.Equal(ef, af), ef, af)
}
format := "unsupported_type: %s"
t := ev.Type()
if t.Kind() != reflect.Ptr {
if p := reflect.PtrTo(t); p.Implements(equalType) {
format = fmt.Sprintf("%s (%s fulfills AssertEqualizer)", format, p.String())
}
}
return fmt.Errorf(format, t.String())
} | geomtest/equal.go | 0.73914 | 0.5564 | equal.go | starcoder |
package info
import (
"fmt"
"regexp"
"strings"
)
// ignore line contains:
// wp-admin
// DateRegex is a regex that catches the date from the log
var DateRegex *regexp.Regexp
func init() {
DateRegex = regexp.MustCompile(`\[.* [+-][0-9]*\]`)
}
// Info represents an entire log entry
type Info struct {
IP string
Date Date
IsBot bool
IsUser bool
IsClientError bool
}
// Data represents all the access log data organized into two maps with IP as key and Info as value
type Data struct {
All map[string]Info
FromDate map[string]Info
}
// GetInfoAtDay parses the contents of a given log at a given day
func GetInfoAtDay(infoMap Data, str string, day string) (Info, error) {
none := Info{IP: "0", IsBot: false, IsUser: false, IsClientError: false}
aux := strings.SplitN(str, " ", 2)
ip := aux[0]
d := [2]byte{day[0], day[1]}
m := [2]byte{day[3], day[4]}
y := [4]byte{day[6], day[7], day[8], day[9]}
maybeDate := DateRegex.FindString(aux[1])
if len(maybeDate) < 23 {
return none, fmt.Errorf("Invalid date")
}
info := CreateInfo(ip, aux[1], maybeDate)
if info.IP == "0" {
return none, nil
}
if info.Date.CompareDay(d) < 0 && info.Date.CompareMonth(m) <= 0 && info.Date.CompareYear(y) <= 0 {
_, ok := infoMap.All[ip]
if ok {
return none, nil
}
infoMap.All[ip] = info
} else if info.Date.CompareDay(d) == 0 && info.Date.CompareMonth(m) == 0 && info.Date.CompareYear(y) == 0 {
_, ok := infoMap.FromDate[ip]
if ok {
return none, nil
}
infoMap.FromDate[ip] = info
}
return info, nil
}
// GetInfoAtMonth parses the contents of a given log at a given month
func GetInfoAtMonth(infoMap Data, str string, month string) (Info, error) {
none := Info{IP: "0", IsBot: false, IsUser: false, IsClientError: false}
aux := strings.SplitN(str, " ", 2)
ip := aux[0]
m := [2]byte{month[0], month[1]}
y := [4]byte{month[3], month[4], month[5], month[6]}
maybeDate := DateRegex.FindString(aux[1])
if len(maybeDate) < 23 {
return none, fmt.Errorf("Invalid date")
}
info := CreateInfo(ip, aux[1], maybeDate)
if info.IP == "0" {
return none, nil
}
if info.Date.CompareMonth(m) < 0 && info.Date.CompareYear(y) <= 0 {
_, ok := infoMap.All[ip]
if ok {
return none, nil
}
infoMap.All[ip] = info
} else if info.Date.CompareMonth(m) == 0 && info.Date.CompareYear(y) == 0 {
_, ok := infoMap.FromDate[ip]
if ok {
return none, nil
}
infoMap.FromDate[ip] = info
}
return info, nil
}
// GetInfoAtYear parses the contents of a given log at a given year
func GetInfoAtYear(infoMap Data, str string, year string) (Info, error) {
none := Info{IP: "0", IsBot: false, IsUser: false, IsClientError: false}
aux := strings.SplitN(str, " ", 2)
ip := aux[0]
y := [4]byte{year[0], year[1], year[2], year[3]}
maybeDate := DateRegex.FindString(aux[1])
if len(maybeDate) < 23 {
return none, fmt.Errorf("Invalid date")
}
info := CreateInfo(ip, aux[1], maybeDate)
if info.IP == "0" {
return none, nil
}
if info.Date.CompareYear(y) < 0 {
_, ok := infoMap.All[ip]
if ok {
return none, nil
}
infoMap.All[ip] = info
} else if info.Date.CompareYear(y) == 0 {
_, ok := infoMap.FromDate[ip]
if ok {
return none, nil
}
infoMap.FromDate[ip] = info
}
return info, nil
}
// GetAllInfo parses all contents of a given log
func GetAllInfo(allMap map[string]Info, str string) (Info, error) {
none := Info{IP: "0", IsBot: false, IsUser: false, IsClientError: false}
aux := strings.SplitN(str, " ", 2)
ip := aux[0]
_, ok := allMap[ip]
if ok {
return none, nil
}
maybeDate := DateRegex.FindString(aux[1])
if len(maybeDate) < 23 {
return none, fmt.Errorf("Invalid date")
}
info := CreateInfo(ip, aux[1], maybeDate)
if info.IP == "0" {
return none, nil
}
allMap[ip] = info
return info, nil
}
// CreateInfo returns a Info type or error
func CreateInfo(ip string, str string, maybeDate string) Info {
info := Info{IP: "0", IsBot: false, IsUser: false, IsClientError: false}
date := Date{
Day: [2]byte{maybeDate[1], maybeDate[2]},
Month: StringToMonth(maybeDate[4:7]),
Year: [4]byte{maybeDate[8], maybeDate[9], maybeDate[10], maybeDate[11]},
DateTime: maybeDate[1:21],
}
botFlag := strings.Contains(str, "wp-admin")
clientError := strings.Contains(str, "HTTP/1.1\" 4")
userFlag := strings.Contains(str, "assets")
if !botFlag && !userFlag && !clientError {
return info
}
info = Info{
IP: ip,
Date: date,
IsBot: botFlag,
IsUser: userFlag,
IsClientError: clientError,
}
return info
}
// String method of Info
func (i Info) String() string {
str := ""
if i.IP == "0" {
return str
}
if i.IsBot {
str += i.Date.DateTime + ": Found a bot -> " + i.IP
} else if i.IsUser {
str += i.Date.DateTime + ": Found a user -> " + i.IP
} else if i.IsClientError {
str += i.Date.DateTime + ": Found a client error request -> " + i.IP
}
return str
} | pkg/info/info.go | 0.606615 | 0.421076 | info.go | starcoder |
package main
import (
"bytes"
"encoding/gob"
"fmt"
"math"
"sort"
"time"
)
type BufferedStats struct {
FlushIntervalMS int
Counts map[string]float64
Gauges map[string]float64
Sets map[string]map[float64]struct{}
Timers map[string][]float64
// When clear_stats_between_flushes = false, this is used to preserve
// {count, gauge, set} names between flushes.
PersistentKeys map[string]map[string]struct{}
// When clear_gauges = true, gauge keys are cleared after the
// expiration time is reached.
GaugeExpirationKeys map[string]time.Time
}
func NewBufferedStats(flushIntervalMS int) *BufferedStats {
return &BufferedStats{
FlushIntervalMS: flushIntervalMS,
Counts: make(map[string]float64),
Gauges: make(map[string]float64),
Sets: make(map[string]map[float64]struct{}),
Timers: make(map[string][]float64),
PersistentKeys: map[string]map[string]struct{}{
"count": make(map[string]struct{}),
"rate": make(map[string]struct{}),
"set": make(map[string]struct{}),
},
GaugeExpirationKeys: make(map[string]time.Time),
}
}
func (c *BufferedStats) AddCount(key string, delta float64) { c.Counts[key] += delta }
func (c *BufferedStats) SetGauge(key string, value float64) { c.Gauges[key] = value }
func (c *BufferedStats) SetGaugeExpiration(key string, ttl time.Duration) {
c.GaugeExpirationKeys[key] = time.Now().Add(ttl)
}
func (c *BufferedStats) AddSetItem(key string, item float64) {
set, ok := c.Sets[key]
if ok {
set[item] = struct{}{}
} else {
c.Sets[key] = map[float64]struct{}{item: {}}
}
}
func (c *BufferedStats) RecordTimer(key string, value float64) {
c.Timers[key] = append(c.Timers[key], value)
}
// Merge merges in another BufferedStats. Right now it only adds in Counts
// (because only counts can be forwarded).
func (c *BufferedStats) Merge(c2 *BufferedStats) {
for name, value := range c2.Counts {
c.AddCount(name, value)
}
}
// computeDerived post-processes the stats to add in the derived metrics and
// returns a map of all the key-value stats grouped by type.
func (c *BufferedStats) computeDerived() map[string]map[string]float64 {
result := map[string]map[string]float64{
// Put in the stats we've already got.
"count": c.Counts,
"gauge": c.Gauges,
}
// Empty maps for values to fill in.
for _, k := range []string{"rate", "set"} {
result[k] = make(map[string]float64)
}
for _, k := range []string{"count", "rate", "sum", "mean", "stdev", "median", "min", "max"} {
result["timer."+k] = make(map[string]float64)
}
// Compute the per-second rate for each counter.
rateFactor := float64(c.FlushIntervalMS) / 1000
for key, value := range c.Counts {
result["rate"][key] = value / rateFactor
}
// Get the size of each set.
for key, value := range c.Sets {
result["set"][key] = float64(len(value))
}
// Process the various stats for each timer.
for key, values := range c.Timers {
if len(values) == 0 {
continue
}
// Useful for order statistics (technically there are faster
// algorithms though).
sort.Float64s(values)
count := float64(len(values))
result["timer.count"][key] = count
// rate is the rate (per second) at which timings were recorded.
result["timer.rate"][key] = count / rateFactor
// sum is the total sum of all timings. You can use count and
// sum to compute statistics across buckets.
sum := 0.0
for _, t := range values {
sum += t
}
result["timer.sum"][key] = sum
mean := sum / count
result["timer.mean"][key] = mean
sumSquares := 0.0
for _, v := range values {
d := v - mean
sumSquares += d * d
}
result["timer.stdev"][key] = math.Sqrt(sumSquares / count)
result["timer.min"][key] = values[0]
result["timer.max"][key] = values[len(values)-1]
if len(values)%2 == 0 {
result["timer.median"][key] = float64(values[len(values)/2-1]+values[len(values)/2]) / 2
} else {
result["timer.median"][key] = float64(values[len(values)/2])
}
}
// Add in any keys in PersistentKeys which don't already have values.
for typ, keys := range c.PersistentKeys {
for k := range keys {
if _, ok := result[typ][k]; !ok {
result[typ][k] = 0.0
}
}
}
return result
}
// CreateForwardMessage buffers up stats for forwarding to another gost
// instance. Right now it only serializes the counts, because they are all that
// may be forwarded.
// TODO: We could switch to a simple binary wire format to avoid reflection if
// gob ends up being a bottleneck.
func (c *BufferedStats) CreateForwardMessage() (n int, msg []byte, err error) {
buf := &bytes.Buffer{}
encoder := gob.NewEncoder(buf)
if err := encoder.Encode(c.Counts); err != nil {
return 0, nil, err
}
return len(c.Counts), buf.Bytes(), nil
}
// CreateGraphiteMessage buffers up a graphite message. c should not be used
// after calling this method. namespace and timestamp are applied to all the
// keys; countGaugeName is the name of a counter appended to the message that
// lists the number of keys written. n is the number of keys written in total
// and msg is the graphite message ready to send.
// NOTE: We could write directly to the connection and avoid the extra buffering
// but this allows us to use separate goroutines to write to graphite
// (potentially slow) and aggregate (happening all the time).
func (c *BufferedStats) CreateGraphiteMessage(namespace, countGaugeName string,
timestamp time.Time) (n int, msg []byte) {
metrics := c.computeDerived()
buf := &bytes.Buffer{}
ts := timestamp.Unix()
for typ, s := range metrics {
for key, value := range s {
n++
fmt.Fprintf(buf, "%s.%s.%s %f %d\n", namespace, key, typ, value, ts)
}
}
n++
fmt.Fprintf(buf, "%s.gost.%s.gauge %f %d\n", namespace, countGaugeName, float64(n), ts)
return n, buf.Bytes()
}
// clearStats resets the state of all the stat types.
// - Counters and sets are deleted, but their names are recorded if
// persistStats is true.
// - Timers are always cleared because there aren't great semantics for
// persisting them.
// - Gauges are preserved as-is unless persistStats is false.
// Expired gauges are always cleared.
func (c *BufferedStats) Clear(persistStats bool) {
if persistStats {
for k := range c.Counts {
c.PersistentKeys["count"][k] = struct{}{}
c.PersistentKeys["rate"][k] = struct{}{}
}
for k := range c.Sets {
c.PersistentKeys["set"][k] = struct{}{}
}
} else {
c.Gauges = make(map[string]float64)
}
now := time.Now()
for key, expiration := range c.GaugeExpirationKeys {
if now.After(expiration) {
delete(c.Gauges, key)
delete(c.GaugeExpirationKeys, key)
}
}
c.Timers = make(map[string][]float64)
c.Counts = make(map[string]float64)
c.Sets = make(map[string]map[float64]struct{})
} | bufferedstats.go | 0.594787 | 0.443841 | bufferedstats.go | starcoder |
package twistededwards
import (
"math/big"
"github.com/consensys/gnark/frontend"
)
// Point point on a twisted Edwards curve in a Snark cs
type Point struct {
X, Y frontend.Variable
}
// Neg computes the negative of a point in SNARK coordinates
func (p *Point) Neg(api frontend.API, p1 *Point) *Point {
p.X = api.Neg(p1.X)
p.Y = p1.Y
return p
}
// MustBeOnCurve checks if a point is on the reduced twisted Edwards curve
// a*x² + y² = 1 + d*x²*y².
func (p *Point) MustBeOnCurve(api frontend.API, curve EdCurve) {
one := big.NewInt(1)
xx := api.Mul(p.X, p.X)
yy := api.Mul(p.Y, p.Y)
axx := api.Mul(xx, &curve.A)
lhs := api.Add(axx, yy)
dxx := api.Mul(xx, &curve.D)
dxxyy := api.Mul(dxx, yy)
rhs := api.Add(dxxyy, one)
api.AssertIsEqual(lhs, rhs)
}
// Add Adds two points on a twisted edwards curve (eg jubjub)
// p1, p2, c are respectively: the point to add, a known base point, and the parameters of the twisted edwards curve
func (p *Point) Add(api frontend.API, p1, p2 *Point, curve EdCurve) *Point {
// https://eprint.iacr.org/2008/013.pdf
n11 := api.Mul(p1.X, p2.Y)
n12 := api.Mul(p1.Y, p2.X)
n1 := api.Add(n11, n12)
n21 := api.Mul(p1.Y, p2.Y)
n22 := api.Mul(p1.X, p2.X)
an22 := api.Mul(n22, &curve.A)
n2 := api.Sub(n21, an22)
d11 := api.Mul(curve.D, n11, n12)
d1 := api.Add(1, d11)
d2 := api.Sub(1, d11)
p.X = api.DivUnchecked(n1, d1)
p.Y = api.DivUnchecked(n2, d2)
return p
}
// Double doubles a points in SNARK coordinates
func (p *Point) Double(api frontend.API, p1 *Point, curve EdCurve) *Point {
u := api.Mul(p1.X, p1.Y)
v := api.Mul(p1.X, p1.X)
w := api.Mul(p1.Y, p1.Y)
n1 := api.Mul(2, u)
av := api.Mul(v, &curve.A)
n2 := api.Sub(w, av)
d1 := api.Add(w, av)
d2 := api.Sub(2, d1)
p.X = api.DivUnchecked(n1, d1)
p.Y = api.DivUnchecked(n2, d2)
return p
}
// ScalarMul computes the scalar multiplication of a point on a twisted Edwards curve
// p1: base point (as snark point)
// curve: parameters of the Edwards curve
// scal: scalar as a SNARK constraint
// Standard left to right double and add
func (p *Point) ScalarMul(api frontend.API, p1 *Point, scalar frontend.Variable, curve EdCurve) *Point {
// first unpack the scalar
b := api.ToBinary(scalar)
res := Point{}
tmp := Point{}
A := Point{}
B := Point{}
A.Double(api, p1, curve)
B.Add(api, &A, p1, curve)
n := len(b) - 1
res.X = api.Lookup2(b[n], b[n-1], 0, A.X, p1.X, B.X)
res.Y = api.Lookup2(b[n], b[n-1], 1, A.Y, p1.Y, B.Y)
for i := n - 2; i >= 1; i -= 2 {
res.Double(api, &res, curve).
Double(api, &res, curve)
tmp.X = api.Lookup2(b[i], b[i-1], 0, A.X, p1.X, B.X)
tmp.Y = api.Lookup2(b[i], b[i-1], 1, A.Y, p1.Y, B.Y)
res.Add(api, &res, &tmp, curve)
}
if n%2 == 0 {
res.Double(api, &res, curve)
tmp.Add(api, &res, p1, curve)
res.X = api.Select(b[0], tmp.X, res.X)
res.Y = api.Select(b[0], tmp.Y, res.Y)
}
p.X = res.X
p.Y = res.Y
return p
}
// DoubleBaseScalarMul computes s1*P1+s2*P2
// where P1 and P2 are points on a twisted Edwards curve
// and s1, s2 scalars.
func (p *Point) DoubleBaseScalarMul(api frontend.API, p1, p2 *Point, s1, s2 frontend.Variable, curve EdCurve) *Point {
// first unpack the scalars
b1 := api.ToBinary(s1)
b2 := api.ToBinary(s2)
res := Point{}
tmp := Point{}
sum := Point{}
sum.Add(api, p1, p2, curve)
n := len(b1)
res.X = api.Lookup2(b1[n-1], b2[n-1], 0, p1.X, p2.X, sum.X)
res.Y = api.Lookup2(b1[n-1], b2[n-1], 1, p1.Y, p2.Y, sum.Y)
for i := n - 2; i >= 0; i-- {
res.Double(api, &res, curve)
tmp.X = api.Lookup2(b1[i], b2[i], 0, p1.X, p2.X, sum.X)
tmp.Y = api.Lookup2(b1[i], b2[i], 1, p1.Y, p2.Y, sum.Y)
res.Add(api, &res, &tmp, curve)
}
p.X = res.X
p.Y = res.Y
return p
} | std/algebra/twistededwards/point.go | 0.84137 | 0.446555 | point.go | starcoder |
package aggregaterange
import (
"github.com/pkg/errors"
"math/big"
"sync"
"github.com/incognitochain/incognito-chain/common"
"github.com/incognitochain/incognito-chain/privacy"
)
// This protocol proves in zero-knowledge that a list of committed values falls in [0, 2^64)
type AggregatedRangeWitness struct {
values []*big.Int
rands []*big.Int
}
type AggregatedRangeProof struct {
cmsValue []*privacy.EllipticPoint
a *privacy.EllipticPoint
s *privacy.EllipticPoint
t1 *privacy.EllipticPoint
t2 *privacy.EllipticPoint
tauX *big.Int
tHat *big.Int
mu *big.Int
innerProductProof *InnerProductProof
}
func (proof AggregatedRangeProof) ValidateSanity() bool {
for i := 0; i < len(proof.cmsValue); i++ {
if !proof.cmsValue[i].IsSafe() {
return false
}
}
if !proof.a.IsSafe() {
return false
}
if !proof.s.IsSafe() {
return false
}
if !proof.t1.IsSafe() {
return false
}
if !proof.t2.IsSafe() {
return false
}
if proof.tauX.BitLen() > 256 {
return false
}
if proof.tHat.BitLen() > 256 {
return false
}
if proof.mu.BitLen() > 256 {
return false
}
return proof.innerProductProof.ValidateSanity()
}
func (proof *AggregatedRangeProof) Init() {
proof.a = new(privacy.EllipticPoint)
proof.a.Zero()
proof.s = new(privacy.EllipticPoint)
proof.s.Zero()
proof.t1 = new(privacy.EllipticPoint)
proof.t1.Zero()
proof.t2 = new(privacy.EllipticPoint)
proof.t2.Zero()
proof.tauX = new(big.Int)
proof.tHat = new(big.Int)
proof.mu = new(big.Int)
proof.innerProductProof = new(InnerProductProof)
}
func (proof AggregatedRangeProof) IsNil() bool {
if proof.a == nil {
return true
}
if proof.s == nil {
return true
}
if proof.t1 == nil {
return true
}
if proof.t2 == nil {
return true
}
if proof.tauX == nil {
return true
}
if proof.tHat == nil {
return true
}
if proof.mu == nil {
return true
}
return proof.innerProductProof == nil
}
func (proof AggregatedRangeProof) Bytes() []byte {
var res []byte
if proof.IsNil() {
return []byte{}
}
res = append(res, byte(len(proof.cmsValue)))
for i := 0; i < len(proof.cmsValue); i++ {
res = append(res, proof.cmsValue[i].Compress()...)
}
res = append(res, proof.a.Compress()...)
res = append(res, proof.s.Compress()...)
res = append(res, proof.t1.Compress()...)
res = append(res, proof.t2.Compress()...)
res = append(res, common.AddPaddingBigInt(proof.tauX, common.BigIntSize)...)
res = append(res, common.AddPaddingBigInt(proof.tHat, common.BigIntSize)...)
res = append(res, common.AddPaddingBigInt(proof.mu, common.BigIntSize)...)
res = append(res, proof.innerProductProof.Bytes()...)
//privacy.Logger.Log.Debugf("BYTES ------------ %v\n", res)
return res
}
func (proof *AggregatedRangeProof) SetBytes(bytes []byte) error {
if len(bytes) == 0 {
return nil
}
//privacy.Logger.Log.Debugf("BEFORE SETBYTES ------------ %v\n", bytes)
lenValues := int(bytes[0])
offset := 1
proof.cmsValue = make([]*privacy.EllipticPoint, lenValues)
for i := 0; i < lenValues; i++ {
proof.cmsValue[i] = new(privacy.EllipticPoint)
err := proof.cmsValue[i].Decompress(bytes[offset : offset+privacy.CompressedEllipticPointSize])
if err != nil {
return err
}
offset += privacy.CompressedEllipticPointSize
}
proof.a = new(privacy.EllipticPoint)
err := proof.a.Decompress(bytes[offset:])
if err != nil {
return err
}
offset += privacy.CompressedEllipticPointSize
proof.s = new(privacy.EllipticPoint)
err = proof.s.Decompress(bytes[offset:])
if err != nil {
return err
}
offset += privacy.CompressedEllipticPointSize
proof.t1 = new(privacy.EllipticPoint)
err = proof.t1.Decompress(bytes[offset:])
if err != nil {
return err
}
offset += privacy.CompressedEllipticPointSize
proof.t2 = new(privacy.EllipticPoint)
err = proof.t2.Decompress(bytes[offset:])
if err != nil {
return err
}
offset += privacy.CompressedEllipticPointSize
proof.tauX = new(big.Int).SetBytes(bytes[offset : offset+common.BigIntSize])
offset += common.BigIntSize
proof.tHat = new(big.Int).SetBytes(bytes[offset : offset+common.BigIntSize])
offset += common.BigIntSize
proof.mu = new(big.Int).SetBytes(bytes[offset : offset+common.BigIntSize])
offset += common.BigIntSize
proof.innerProductProof = new(InnerProductProof)
proof.innerProductProof.SetBytes(bytes[offset:])
//privacy.Logger.Log.Debugf("AFTER SETBYTES ------------ %v\n", proof.Bytes())
return nil
}
func (wit *AggregatedRangeWitness) Set(values []*big.Int, rands []*big.Int) {
numValue := len(values)
wit.values = make([]*big.Int, numValue)
wit.rands = make([]*big.Int, numValue)
for i := range values {
wit.values[i] = new(big.Int).Set(values[i])
wit.rands[i] = new(big.Int).Set(rands[i])
}
}
func (wit AggregatedRangeWitness) Prove() (*AggregatedRangeProof, error) {
proof := new(AggregatedRangeProof)
numValue := len(wit.values)
numValuePad := pad(numValue)
values := make([]*big.Int, numValuePad)
rands := make([]*big.Int, numValuePad)
for i := range wit.values {
values[i] = new(big.Int).Set(wit.values[i])
rands[i] = new(big.Int).Set(wit.rands[i])
}
for i := numValue; i < numValuePad; i++ {
values[i] = big.NewInt(0)
rands[i] = big.NewInt(0)
}
AggParam := newBulletproofParams(numValuePad)
proof.cmsValue = make([]*privacy.EllipticPoint, numValue)
for i := 0; i < numValue; i++ {
proof.cmsValue[i] = privacy.PedCom.CommitAtIndex(values[i], rands[i], privacy.PedersenValueIndex)
}
n := maxExp
// Convert values to binary array
aL := make([]*big.Int, numValuePad*n)
for i, value := range values {
tmp := privacy.ConvertBigIntToBinary(value, n)
for j := 0; j < n; j++ {
aL[i*n+j] = tmp[j]
}
}
twoNumber := big.NewInt(2)
twoVectorN := powerVector(twoNumber, n)
aR := make([]*big.Int, numValuePad*n)
for i := 0; i < numValuePad*n; i++ {
aR[i] = new(big.Int).Sub(aL[i], big.NewInt(1))
aR[i].Mod(aR[i], privacy.Curve.Params().N)
}
// random alpha
alpha := privacy.RandScalar()
// Commitment to aL, aR: A = h^alpha * G^aL * H^aR
A, err := encodeVectors(aL, aR, AggParam.g, AggParam.h)
if err != nil {
return nil, err
}
A = A.Add(privacy.PedCom.G[privacy.PedersenRandomnessIndex].ScalarMult(alpha))
proof.a = A
// Random blinding vectors sL, sR
sL := make([]*big.Int, n*numValuePad)
sR := make([]*big.Int, n*numValuePad)
for i := range sL {
sL[i] = privacy.RandScalar()
sR[i] = privacy.RandScalar()
}
// random rho
rho := privacy.RandScalar()
// Commitment to sL, sR : S = h^rho * G^sL * H^sR
S, err := encodeVectors(sL, sR, AggParam.g, AggParam.h)
if err != nil {
return nil, err
}
S = S.Add(privacy.PedCom.G[privacy.PedersenRandomnessIndex].ScalarMult(rho))
proof.s = S
// challenge y, z
y := generateChallengeForAggRange(AggParam, [][]byte{A.Compress(), S.Compress()})
z := generateChallengeForAggRange(AggParam, [][]byte{A.Compress(), S.Compress(), y.Bytes()})
zNeg := new(big.Int).Neg(z)
zNeg.Mod(zNeg, privacy.Curve.Params().N)
zSquare := new(big.Int).Mul(z, z)
zSquare.Mod(zSquare, privacy.Curve.Params().N)
// l(X) = (aL -z*1^n) + sL*X
yVector := powerVector(y, n*numValuePad)
l0 := vectorAddScalar(aL, zNeg)
l1 := sL
// r(X) = y^n hada (aR +z*1^n + sR*X) + z^2 * 2^n
hadaProduct, err := hadamardProduct(yVector, vectorAddScalar(aR, z))
if err != nil {
return nil, err
}
vectorSum := make([]*big.Int, n*numValuePad)
zTmp := new(big.Int).Set(z)
for j := 0; j < numValuePad; j++ {
zTmp.Mul(zTmp, z)
zTmp.Mod(zTmp, privacy.Curve.Params().N)
for i := 0; i < n; i++ {
vectorSum[j*n+i] = new(big.Int).Mul(twoVectorN[i], zTmp)
vectorSum[j*n+i].Mod(vectorSum[j*n+i], privacy.Curve.Params().N)
}
}
r0, err := vectorAdd(hadaProduct, vectorSum)
if err != nil {
return nil, err
}
r1, err := hadamardProduct(yVector, sR)
if err != nil {
return nil, err
}
//t(X) = <l(X), r(X)> = t0 + t1*X + t2*X^2
//calculate t0 = v*z^2 + delta(y, z)
deltaYZ := new(big.Int).Sub(z, zSquare)
// innerProduct1 = <1^(n*m), y^(n*m)>
innerProduct1 := big.NewInt(0)
for i := 0; i < n*numValuePad; i++ {
innerProduct1 = innerProduct1.Add(innerProduct1, yVector[i])
}
innerProduct1.Mod(innerProduct1, privacy.Curve.Params().N)
deltaYZ.Mul(deltaYZ, innerProduct1)
// innerProduct2 = <1^n, 2^n>
innerProduct2 := big.NewInt(0)
for i := 0; i < n; i++ {
innerProduct2 = innerProduct2.Add(innerProduct2, twoVectorN[i])
}
innerProduct2.Mod(innerProduct2, privacy.Curve.Params().N)
sum := big.NewInt(0)
zTmp = new(big.Int).Set(zSquare)
for j := 0; j < numValuePad; j++ {
zTmp.Mul(zTmp, z)
zTmp.Mod(zTmp, privacy.Curve.Params().N)
sum.Add(sum, zTmp)
}
sum.Mul(sum, innerProduct2)
deltaYZ.Sub(deltaYZ, sum)
deltaYZ.Mod(deltaYZ, privacy.Curve.Params().N)
// t1 = <l1, r0> + <l0, r1>
innerProduct3, err := innerProduct(l1, r0)
if err != nil {
return nil, err
}
innerProduct4, err := innerProduct(l0, r1)
if err != nil {
return nil, err
}
t1 := new(big.Int).Add(innerProduct3, innerProduct4)
t1.Mod(t1, privacy.Curve.Params().N)
// t2 = <l1, r1>
t2, err := innerProduct(l1, r1)
if err != nil {
return nil, err
}
// commitment to t1, t2
tau1 := privacy.RandScalar()
tau2 := privacy.RandScalar()
proof.t1 = privacy.PedCom.CommitAtIndex(t1, tau1, privacy.PedersenValueIndex)
proof.t2 = privacy.PedCom.CommitAtIndex(t2, tau2, privacy.PedersenValueIndex)
// challenge x = hash(G || H || A || S || T1 || T2)
x := generateChallengeForAggRange(AggParam, [][]byte{proof.a.Compress(), proof.s.Compress(), proof.t1.Compress(), proof.t2.Compress()})
xSquare := new(big.Int).Exp(x, twoNumber, privacy.Curve.Params().N)
// lVector = aL - z*1^n + sL*x
lVector, err := vectorAdd(vectorAddScalar(aL, zNeg), vectorMulScalar(sL, x))
if err != nil {
return nil, err
}
// rVector = y^n hada (aR +z*1^n + sR*x) + z^2*2^n
tmpVector, err := vectorAdd(vectorAddScalar(aR, z), vectorMulScalar(sR, x))
if err != nil {
return nil, err
}
rVector, err := hadamardProduct(yVector, tmpVector)
if err != nil {
return nil, err
}
vectorSum = make([]*big.Int, n*numValuePad)
zTmp = new(big.Int).Set(z)
for j := 0; j < numValuePad; j++ {
zTmp.Mul(zTmp, z)
zTmp.Mod(zTmp, privacy.Curve.Params().N)
for i := 0; i < n; i++ {
vectorSum[j*n+i] = new(big.Int).Mul(twoVectorN[i], zTmp)
vectorSum[j*n+i].Mod(vectorSum[j*n+i], privacy.Curve.Params().N)
}
}
rVector, err = vectorAdd(rVector, vectorSum)
if err != nil {
return nil, err
}
// tHat = <lVector, rVector>
proof.tHat, err = innerProduct(lVector, rVector)
if err != nil {
return nil, err
}
// blinding value for tHat: tauX = tau2*x^2 + tau1*x + z^2*rand
proof.tauX = new(big.Int).Mul(tau2, xSquare)
proof.tauX.Add(proof.tauX, new(big.Int).Mul(tau1, x))
zTmp = new(big.Int).Set(z)
tmpBN := new(big.Int)
for j := 0; j < numValuePad; j++ {
zTmp.Mul(zTmp, z)
zTmp.Mod(zTmp, privacy.Curve.Params().N)
proof.tauX.Add(proof.tauX, tmpBN.Mul(zTmp, rands[j]))
}
proof.tauX.Mod(proof.tauX, privacy.Curve.Params().N)
// alpha, rho blind A, S
// mu = alpha + rho*x
proof.mu = new(big.Int).Mul(rho, x)
proof.mu.Add(proof.mu, alpha)
proof.mu.Mod(proof.mu, privacy.Curve.Params().N)
// instead of sending left vector and right vector, we use inner sum argument to reduce proof size from 2*n to 2(log2(n)) + 2
innerProductWit := new(InnerProductWitness)
innerProductWit.a = lVector
innerProductWit.b = rVector
innerProductWit.p, err = encodeVectors(lVector, rVector, AggParam.g, AggParam.h)
if err != nil {
return nil, err
}
innerProductWit.p = innerProductWit.p.Add(AggParam.u.ScalarMult(proof.tHat))
proof.innerProductProof, err = innerProductWit.Prove(AggParam)
if err != nil {
return nil, err
}
return proof, nil
}
func (proof AggregatedRangeProof) Verify() (bool, error) {
numValue := len(proof.cmsValue)
numValuePad := pad(numValue)
tmpcmsValue := proof.cmsValue
for i := numValue; i < numValuePad; i++ {
zero := new(privacy.EllipticPoint)
zero.Zero()
tmpcmsValue = append(tmpcmsValue, zero)
}
AggParam := newBulletproofParams(numValuePad)
n := maxExp
oneNumber := big.NewInt(1)
twoNumber := big.NewInt(2)
oneVector := powerVector(oneNumber, n*numValuePad)
oneVectorN := powerVector(oneNumber, n)
twoVectorN := powerVector(twoNumber, n)
// recalculate challenge y, z
y := generateChallengeForAggRange(AggParam, [][]byte{proof.a.Compress(), proof.s.Compress()})
z := generateChallengeForAggRange(AggParam, [][]byte{proof.a.Compress(), proof.s.Compress(), y.Bytes()})
zNeg := new(big.Int).Neg(z)
zNeg.Mod(zNeg, privacy.Curve.Params().N)
zSquare := new(big.Int).Exp(z, twoNumber, privacy.Curve.Params().N)
// challenge x = hash(G || H || A || S || T1 || T2)
//fmt.Printf("T2: %v\n", proof.t2)
x := generateChallengeForAggRange(AggParam, [][]byte{proof.a.Compress(), proof.s.Compress(), proof.t1.Compress(), proof.t2.Compress()})
xSquare := new(big.Int).Exp(x, twoNumber, privacy.Curve.Params().N)
yVector := powerVector(y, n*numValuePad)
// HPrime = H^(y^(1-i)
HPrime := make([]*privacy.EllipticPoint, n*numValuePad)
var wg sync.WaitGroup
wg.Add(len(HPrime))
for i := 0; i < n*numValuePad; i++ {
go func(i int, wg *sync.WaitGroup) {
defer wg.Done()
HPrime[i] = AggParam.h[i].ScalarMult(new(big.Int).Exp(y, big.NewInt(int64(-i)), privacy.Curve.Params().N))
}(i, &wg)
}
wg.Wait()
// g^tHat * h^tauX = V^(z^2) * g^delta(y,z) * T1^x * T2^(x^2)
deltaYZ := new(big.Int).Sub(z, zSquare)
// innerProduct1 = <1^(n*m), y^(n*m)>
innerProduct1, err := innerProduct(oneVector, yVector)
if err != nil {
return false, privacy.NewPrivacyErr(privacy.CalInnerProductErr, err)
}
deltaYZ.Mul(deltaYZ, innerProduct1)
// innerProduct2 = <1^n, 2^n>
innerProduct2, err := innerProduct(oneVectorN, twoVectorN)
if err != nil {
return false, privacy.NewPrivacyErr(privacy.CalInnerProductErr, err)
}
sum := big.NewInt(0)
zTmp := new(big.Int).Set(zSquare)
for j := 0; j < numValuePad; j++ {
zTmp.Mul(zTmp, z)
zTmp.Mod(zTmp, privacy.Curve.Params().N)
sum.Add(sum, zTmp)
}
sum.Mul(sum, innerProduct2)
deltaYZ.Sub(deltaYZ, sum)
deltaYZ.Mod(deltaYZ, privacy.Curve.Params().N)
left1 := privacy.PedCom.CommitAtIndex(proof.tHat, proof.tauX, privacy.PedersenValueIndex)
var temp1, temp2, temp3 *privacy.EllipticPoint
wg.Add(3)
go func(wg *sync.WaitGroup) {
defer wg.Done()
temp1 = privacy.PedCom.G[privacy.PedersenValueIndex].ScalarMult(deltaYZ)
}(&wg)
go func(wg *sync.WaitGroup) {
defer wg.Done()
temp2 = proof.t1.ScalarMult(x)
}(&wg)
go func(wg *sync.WaitGroup) {
defer wg.Done()
temp3 = proof.t2.ScalarMult(xSquare)
}(&wg)
wg.Wait()
right1 := temp1.Add(temp2).Add(temp3)
expVector := vectorMulScalar(powerVector(z, numValuePad), zSquare)
for i, cm := range tmpcmsValue {
right1 = right1.Add(cm.ScalarMult(expVector[i]))
}
if !left1.IsEqual(right1) {
privacy.Logger.Log.Errorf("verify aggregated range proof statement 1 failed")
return false, errors.New("verify aggregated range proof statement 1 failed")
}
innerProductArgValid := proof.innerProductProof.Verify(AggParam)
if !innerProductArgValid {
privacy.Logger.Log.Errorf("verify aggregated range proof statement 2 failed")
return false, errors.New("verify aggregated range proof statement 2 failed")
}
return true, nil
} | privacy/zeroknowledge/aggregaterange/aggregaterange.go | 0.560373 | 0.444806 | aggregaterange.go | starcoder |
package big
import (
"sort"
)
// StringSlice attaches the methods of RadixSortable to []string, sorting in increasing order.
type StringSlice []string
func (p StringSlice) Len() int { return len(p) }
func (p StringSlice) Less(i, j int) bool { return p[i] < p[j] }
func (p StringSlice) Swap(i, j int) { p[i], p[j] = p[j], p[i] }
func (p StringSlice) RadixKey(i int) (key int) {
item := p[i]
switch len(item) {
case 0:
key = 0
case 1:
key = (1 << 16) * int(item[0])
case 2:
key = (1<<16)*int(item[0]) + (1<<8)*int(item[1])
default:
key = (1<<16)*int(item[0]) + (1<<8)*int(item[1]) + int(item[2])
}
return int(key)
}
func RadixSortStrings(items []string) <-chan int {
return RadixSort(StringSlice(items))
}
// ---------------------------------------------------------------------------------------------------------------------
type RadixSortable interface {
sort.Interface
// Returns the radix-key of the passed element.
RadixKey(i int) int
}
func RadixSort(objects RadixSortable) <-chan int {
out := make(chan int, objects.Len())
// Concurrently sorts each bucket:
go func() {
defer close(out)
if objects == nil {
return
}
const MIN_SIZE = 1000
numObjects := objects.Len()
switch {
// Nothing to sort:
case numObjects == 0:
break
// For a simple problem, a simpler solution:
case numObjects < MIN_SIZE:
buc := newBucket(objects)
for index := 0; index < numObjects; index++ {
buc.items = append(buc.items, index)
}
sort.Sort(buc)
for _, index := range buc.items {
out <- index
}
break
// Lets scale up:
default:
radixSort(out, objects)
}
}()
return out
}
// ---------------------------------------------------------------------------------------------------------------------
type bucket struct {
objects RadixSortable
items []int
pos int
sorted bool
}
func (p *bucket) Len() int {
return len(p.items)
}
func (p *bucket) Less(i, j int) bool {
i1 := p.items[i]
j1 := p.items[j]
return p.objects.Less(i1, j1)
}
func (p *bucket) Swap(i, j int) {
p.items[i], p.items[j] = p.items[j], p.items[i]
}
func newBucket(objects RadixSortable) *bucket {
return &bucket{
objects: objects,
items: make([]int, 0),
pos: 0,
sorted: false}
}
// ---------------------------------------------------------------------------------------------------------------------
func radixSort(out chan int, objects RadixSortable) {
numObjects := objects.Len()
// fmt.Println("Num objects:", numObjects)
// Generates buckets:
buckets := make(map[int]*bucket)
for i := 0; i < numObjects; i++ {
key := objects.RadixKey(i)
buc, ok := buckets[key]
if ok {
buc.items = append(buc.items, i)
} else {
buc = newBucket(objects)
buc.items = append(buc.items, i)
buckets[key] = buc
}
}
numBuckets := len(buckets)
// fmt.Println("Num buckets:", numBuckets)
// Sorts buckets concurrently:
bucketSorted := make(chan *bucket, numBuckets)
for _, buc := range buckets {
go func(buc *bucket) {
sort.Sort(buc)
bucketSorted <- buc
}(buc)
}
// Assigns to each bucket its positional order:
keys := make([]int, 0, numBuckets)
for key := range buckets {
keys = append(keys, key)
}
sort.Ints(keys)
for i, key := range keys {
buckets[key].pos = i
}
// Collects sorted buckets:
var nextToReturn int
for i := 0; i < numBuckets; i++ {
buc := <-bucketSorted
buc.sorted = true
bucketPos := buc.pos
if bucketPos != nextToReturn {
continue
}
// Returns all indices from current bucket:
for _, index := range buc.items {
out <- index
}
nextToReturn++
// Tries to emit as much bucket as possible to the main routine:
for bucketPos += 1; bucketPos < numBuckets; bucketPos++ {
buc = buckets[keys[bucketPos]]
if !buc.sorted {
break
}
for _, index := range buc.items {
out <- index
}
nextToReturn++
}
}
for i := nextToReturn; i < numBuckets; i++ {
buc := buckets[keys[i]]
if !buc.sorted {
break
}
for _, index := range buc.items {
out <- index
}
}
}
// --------------------------------------------------------------------------------------------------------------------- | src/big/bigsort.go | 0.609873 | 0.450359 | bigsort.go | starcoder |
import (
"github.com/kaitai-io/kaitai_struct_go_runtime/kaitai"
"bytes"
)
/**
* BSON, short for Binary JSON, is a binary-encoded serialization of JSON-like documents. Like JSON, BSON supports the embedding of documents and arrays within other documents and arrays. BSON also contains extensions that allow representation of data types that are not part of the JSON spec. For example, BSON has a Date type and a BinData type. BSON can be compared to binary interchange formats, like Protocol Buffers. BSON is more "schemaless" than Protocol Buffers, which can give it an advantage in flexibility but also a slight disadvantage in space efficiency (BSON has overhead for field names within the serialized data). BSON was designed to have the following three characteristics:
* * Lightweight. Keeping spatial overhead to a minimum is important for any data representation format, especially when used over the network.
* * Traversable. BSON is designed to be traversed easily. This is a vital property in its role as the primary data representation for MongoDB.
* * Efficient. Encoding data to BSON and decoding from BSON can be performed very quickly in most languages due to the use of C data types.
*/
type Bson struct {
Len int32
Fields *Bson_ElementsList
Terminator []byte
_io *kaitai.Stream
_root *Bson
_parent interface{}
_raw_Fields []byte
}
func NewBson() *Bson {
return &Bson{
}
}
func (this *Bson) Read(io *kaitai.Stream, parent interface{}, root *Bson) (err error) {
this._io = io
this._parent = parent
this._root = root
tmp1, err := this._io.ReadS4le()
if err != nil {
return err
}
this.Len = int32(tmp1)
tmp2, err := this._io.ReadBytes(int((this.Len - 5)))
if err != nil {
return err
}
tmp2 = tmp2
this._raw_Fields = tmp2
_io__raw_Fields := kaitai.NewStream(bytes.NewReader(this._raw_Fields))
tmp3 := NewBson_ElementsList()
err = tmp3.Read(_io__raw_Fields, this, this._root)
if err != nil {
return err
}
this.Fields = tmp3
tmp4, err := this._io.ReadBytes(int(1))
if err != nil {
return err
}
tmp4 = tmp4
this.Terminator = tmp4
if !(bytes.Equal(this.Terminator, []uint8{0})) {
return kaitai.NewValidationNotEqualError([]uint8{0}, this.Terminator, this._io, "/seq/2")
}
return err
}
/**
* Total number of bytes comprising the document.
*/
/**
* Special internal type used by MongoDB replication and sharding. First 4 bytes are an increment, second 4 are a timestamp.
*/
type Bson_Timestamp struct {
Increment uint32
Timestamp uint32
_io *kaitai.Stream
_root *Bson
_parent *Bson_Element
}
func NewBson_Timestamp() *Bson_Timestamp {
return &Bson_Timestamp{
}
}
func (this *Bson_Timestamp) Read(io *kaitai.Stream, parent *Bson_Element, root *Bson) (err error) {
this._io = io
this._parent = parent
this._root = root
tmp5, err := this._io.ReadU4le()
if err != nil {
return err
}
this.Increment = uint32(tmp5)
tmp6, err := this._io.ReadU4le()
if err != nil {
return err
}
this.Timestamp = uint32(tmp6)
return err
}
/**
* The BSON "binary" or "BinData" datatype is used to represent arrays of bytes. It is somewhat analogous to the Java notion of a ByteArray. BSON binary values have a subtype. This is used to indicate what kind of data is in the byte array. Subtypes from zero to 127 are predefined or reserved. Subtypes from 128-255 are user-defined.
*/
type Bson_BinData_Subtype int
const (
Bson_BinData_Subtype__Generic Bson_BinData_Subtype = 0
Bson_BinData_Subtype__Function Bson_BinData_Subtype = 1
Bson_BinData_Subtype__ByteArrayDeprecated Bson_BinData_Subtype = 2
Bson_BinData_Subtype__UuidDeprecated Bson_BinData_Subtype = 3
Bson_BinData_Subtype__Uuid Bson_BinData_Subtype = 4
Bson_BinData_Subtype__Md5 Bson_BinData_Subtype = 5
Bson_BinData_Subtype__Custom Bson_BinData_Subtype = 128
)
type Bson_BinData struct {
Len int32
Subtype Bson_BinData_Subtype
Content interface{}
_io *kaitai.Stream
_root *Bson
_parent *Bson_Element
_raw_Content []byte
}
func NewBson_BinData() *Bson_BinData {
return &Bson_BinData{
}
}
func (this *Bson_BinData) Read(io *kaitai.Stream, parent *Bson_Element, root *Bson) (err error) {
this._io = io
this._parent = parent
this._root = root
tmp7, err := this._io.ReadS4le()
if err != nil {
return err
}
this.Len = int32(tmp7)
tmp8, err := this._io.ReadU1()
if err != nil {
return err
}
this.Subtype = Bson_BinData_Subtype(tmp8)
switch (this.Subtype) {
case Bson_BinData_Subtype__ByteArrayDeprecated:
tmp9, err := this._io.ReadBytes(int(this.Len))
if err != nil {
return err
}
tmp9 = tmp9
this._raw_Content = tmp9
_io__raw_Content := kaitai.NewStream(bytes.NewReader(this._raw_Content))
tmp10 := NewBson_BinData_ByteArrayDeprecated()
err = tmp10.Read(_io__raw_Content, this, this._root)
if err != nil {
return err
}
this.Content = tmp10
default:
tmp11, err := this._io.ReadBytes(int(this.Len))
if err != nil {
return err
}
tmp11 = tmp11
this._raw_Content = tmp11
}
return err
}
/**
* The BSON "binary" or "BinData" datatype is used to represent arrays of bytes. It is somewhat analogous to the Java notion of a ByteArray. BSON binary values have a subtype. This is used to indicate what kind of data is in the byte array. Subtypes from zero to 127 are predefined or reserved. Subtypes from 128-255 are user-defined.
*/
type Bson_BinData_ByteArrayDeprecated struct {
Len int32
Content []byte
_io *kaitai.Stream
_root *Bson
_parent *Bson_BinData
}
func NewBson_BinData_ByteArrayDeprecated() *Bson_BinData_ByteArrayDeprecated {
return &Bson_BinData_ByteArrayDeprecated{
}
}
func (this *Bson_BinData_ByteArrayDeprecated) Read(io *kaitai.Stream, parent *Bson_BinData, root *Bson) (err error) {
this._io = io
this._parent = parent
this._root = root
tmp12, err := this._io.ReadS4le()
if err != nil {
return err
}
this.Len = int32(tmp12)
tmp13, err := this._io.ReadBytes(int(this.Len))
if err != nil {
return err
}
tmp13 = tmp13
this.Content = tmp13
return err
}
type Bson_ElementsList struct {
Elements []*Bson_Element
_io *kaitai.Stream
_root *Bson
_parent *Bson
}
func NewBson_ElementsList() *Bson_ElementsList {
return &Bson_ElementsList{
}
}
func (this *Bson_ElementsList) Read(io *kaitai.Stream, parent *Bson, root *Bson) (err error) {
this._io = io
this._parent = parent
this._root = root
for i := 1;; i++ {
tmp14, err := this._io.EOF()
if err != nil {
return err
}
if tmp14 {
break
}
tmp15 := NewBson_Element()
err = tmp15.Read(this._io, this, this._root)
if err != nil {
return err
}
this.Elements = append(this.Elements, tmp15)
}
return err
}
type Bson_Cstring struct {
Str string
_io *kaitai.Stream
_root *Bson
_parent interface{}
}
func NewBson_Cstring() *Bson_Cstring {
return &Bson_Cstring{
}
}
func (this *Bson_Cstring) Read(io *kaitai.Stream, parent interface{}, root *Bson) (err error) {
this._io = io
this._parent = parent
this._root = root
tmp16, err := this._io.ReadBytesTerm(0, false, true, true)
if err != nil {
return err
}
this.Str = string(tmp16)
return err
}
/**
* MUST NOT contain '\x00', hence it is not full UTF-8.
*/
type Bson_String struct {
Len int32
Str string
Terminator []byte
_io *kaitai.Stream
_root *Bson
_parent interface{}
}
func NewBson_String() *Bson_String {
return &Bson_String{
}
}
func (this *Bson_String) Read(io *kaitai.Stream, parent interface{}, root *Bson) (err error) {
this._io = io
this._parent = parent
this._root = root
tmp17, err := this._io.ReadS4le()
if err != nil {
return err
}
this.Len = int32(tmp17)
tmp18, err := this._io.ReadBytes(int((this.Len - 1)))
if err != nil {
return err
}
tmp18 = tmp18
this.Str = string(tmp18)
tmp19, err := this._io.ReadBytes(int(1))
if err != nil {
return err
}
tmp19 = tmp19
this.Terminator = tmp19
if !(bytes.Equal(this.Terminator, []uint8{0})) {
return kaitai.NewValidationNotEqualError([]uint8{0}, this.Terminator, this._io, "/types/string/seq/2")
}
return err
}
type Bson_Element_BsonType int
const (
Bson_Element_BsonType__MinKey Bson_Element_BsonType = -1
Bson_Element_BsonType__EndOfObject Bson_Element_BsonType = 0
Bson_Element_BsonType__NumberDouble Bson_Element_BsonType = 1
Bson_Element_BsonType__String Bson_Element_BsonType = 2
Bson_Element_BsonType__Document Bson_Element_BsonType = 3
Bson_Element_BsonType__Array Bson_Element_BsonType = 4
Bson_Element_BsonType__BinData Bson_Element_BsonType = 5
Bson_Element_BsonType__Undefined Bson_Element_BsonType = 6
Bson_Element_BsonType__ObjectId Bson_Element_BsonType = 7
Bson_Element_BsonType__Boolean Bson_Element_BsonType = 8
Bson_Element_BsonType__UtcDatetime Bson_Element_BsonType = 9
Bson_Element_BsonType__JstNull Bson_Element_BsonType = 10
Bson_Element_BsonType__RegEx Bson_Element_BsonType = 11
Bson_Element_BsonType__DbPointer Bson_Element_BsonType = 12
Bson_Element_BsonType__Javascript Bson_Element_BsonType = 13
Bson_Element_BsonType__Symbol Bson_Element_BsonType = 14
Bson_Element_BsonType__CodeWithScope Bson_Element_BsonType = 15
Bson_Element_BsonType__NumberInt Bson_Element_BsonType = 16
Bson_Element_BsonType__Timestamp Bson_Element_BsonType = 17
Bson_Element_BsonType__NumberLong Bson_Element_BsonType = 18
Bson_Element_BsonType__NumberDecimal Bson_Element_BsonType = 19
Bson_Element_BsonType__MaxKey Bson_Element_BsonType = 127
)
type Bson_Element struct {
TypeByte Bson_Element_BsonType
Name *Bson_Cstring
Content interface{}
_io *kaitai.Stream
_root *Bson
_parent *Bson_ElementsList
}
func NewBson_Element() *Bson_Element {
return &Bson_Element{
}
}
func (this *Bson_Element) Read(io *kaitai.Stream, parent *Bson_ElementsList, root *Bson) (err error) {
this._io = io
this._parent = parent
this._root = root
tmp20, err := this._io.ReadU1()
if err != nil {
return err
}
this.TypeByte = Bson_Element_BsonType(tmp20)
tmp21 := NewBson_Cstring()
err = tmp21.Read(this._io, this, this._root)
if err != nil {
return err
}
this.Name = tmp21
switch (this.TypeByte) {
case Bson_Element_BsonType__CodeWithScope:
tmp22 := NewBson_CodeWithScope()
err = tmp22.Read(this._io, this, this._root)
if err != nil {
return err
}
this.Content = tmp22
case Bson_Element_BsonType__RegEx:
tmp23 := NewBson_RegEx()
err = tmp23.Read(this._io, this, this._root)
if err != nil {
return err
}
this.Content = tmp23
case Bson_Element_BsonType__NumberDouble:
tmp24, err := this._io.ReadF8le()
if err != nil {
return err
}
this.Content = tmp24
case Bson_Element_BsonType__Symbol:
tmp25 := NewBson_String()
err = tmp25.Read(this._io, this, this._root)
if err != nil {
return err
}
this.Content = tmp25
case Bson_Element_BsonType__Timestamp:
tmp26 := NewBson_Timestamp()
err = tmp26.Read(this._io, this, this._root)
if err != nil {
return err
}
this.Content = tmp26
case Bson_Element_BsonType__NumberInt:
tmp27, err := this._io.ReadS4le()
if err != nil {
return err
}
this.Content = tmp27
case Bson_Element_BsonType__Document:
tmp28 := NewBson()
err = tmp28.Read(this._io, this, nil)
if err != nil {
return err
}
this.Content = tmp28
case Bson_Element_BsonType__ObjectId:
tmp29 := NewBson_ObjectId()
err = tmp29.Read(this._io, this, this._root)
if err != nil {
return err
}
this.Content = tmp29
case Bson_Element_BsonType__Javascript:
tmp30 := NewBson_String()
err = tmp30.Read(this._io, this, this._root)
if err != nil {
return err
}
this.Content = tmp30
case Bson_Element_BsonType__UtcDatetime:
tmp31, err := this._io.ReadS8le()
if err != nil {
return err
}
this.Content = tmp31
case Bson_Element_BsonType__Boolean:
tmp32, err := this._io.ReadU1()
if err != nil {
return err
}
this.Content = tmp32
case Bson_Element_BsonType__NumberLong:
tmp33, err := this._io.ReadS8le()
if err != nil {
return err
}
this.Content = tmp33
case Bson_Element_BsonType__BinData:
tmp34 := NewBson_BinData()
err = tmp34.Read(this._io, this, this._root)
if err != nil {
return err
}
this.Content = tmp34
case Bson_Element_BsonType__String:
tmp35 := NewBson_String()
err = tmp35.Read(this._io, this, this._root)
if err != nil {
return err
}
this.Content = tmp35
case Bson_Element_BsonType__DbPointer:
tmp36 := NewBson_DbPointer()
err = tmp36.Read(this._io, this, this._root)
if err != nil {
return err
}
this.Content = tmp36
case Bson_Element_BsonType__Array:
tmp37 := NewBson()
err = tmp37.Read(this._io, this, nil)
if err != nil {
return err
}
this.Content = tmp37
case Bson_Element_BsonType__NumberDecimal:
tmp38 := NewBson_F16()
err = tmp38.Read(this._io, this, this._root)
if err != nil {
return err
}
this.Content = tmp38
}
return err
}
type Bson_DbPointer struct {
Namespace *Bson_String
Id *Bson_ObjectId
_io *kaitai.Stream
_root *Bson
_parent *Bson_Element
}
func NewBson_DbPointer() *Bson_DbPointer {
return &Bson_DbPointer{
}
}
func (this *Bson_DbPointer) Read(io *kaitai.Stream, parent *Bson_Element, root *Bson) (err error) {
this._io = io
this._parent = parent
this._root = root
tmp39 := NewBson_String()
err = tmp39.Read(this._io, this, this._root)
if err != nil {
return err
}
this.Namespace = tmp39
tmp40 := NewBson_ObjectId()
err = tmp40.Read(this._io, this, this._root)
if err != nil {
return err
}
this.Id = tmp40
return err
}
/**
* Implements unsigned 24-bit (3 byte) integer.
*/
type Bson_U3 struct {
B1 uint8
B2 uint8
B3 uint8
_io *kaitai.Stream
_root *Bson
_parent *Bson_ObjectId
_f_value bool
value int
}
func NewBson_U3() *Bson_U3 {
return &Bson_U3{
}
}
func (this *Bson_U3) Read(io *kaitai.Stream, parent *Bson_ObjectId, root *Bson) (err error) {
this._io = io
this._parent = parent
this._root = root
tmp41, err := this._io.ReadU1()
if err != nil {
return err
}
this.B1 = tmp41
tmp42, err := this._io.ReadU1()
if err != nil {
return err
}
this.B2 = tmp42
tmp43, err := this._io.ReadU1()
if err != nil {
return err
}
this.B3 = tmp43
return err
}
func (this *Bson_U3) Value() (v int, err error) {
if (this._f_value) {
return this.value, nil
}
this.value = int(((this.B1 | (this.B2 << 8)) | (this.B3 << 16)))
this._f_value = true
return this.value, nil
}
type Bson_CodeWithScope struct {
Id int32
Source *Bson_String
Scope *Bson
_io *kaitai.Stream
_root *Bson
_parent *Bson_Element
}
func NewBson_CodeWithScope() *Bson_CodeWithScope {
return &Bson_CodeWithScope{
}
}
func (this *Bson_CodeWithScope) Read(io *kaitai.Stream, parent *Bson_Element, root *Bson) (err error) {
this._io = io
this._parent = parent
this._root = root
tmp44, err := this._io.ReadS4le()
if err != nil {
return err
}
this.Id = int32(tmp44)
tmp45 := NewBson_String()
err = tmp45.Read(this._io, this, this._root)
if err != nil {
return err
}
this.Source = tmp45
tmp46 := NewBson()
err = tmp46.Read(this._io, this, nil)
if err != nil {
return err
}
this.Scope = tmp46
return err
}
/**
* mapping from identifiers to values, representing the scope in which the string should be evaluated.
*/
/**
* 128-bit IEEE 754-2008 decimal floating point
*/
type Bson_F16 struct {
Str bool
Exponent uint64
SignificandHi uint64
SignificandLo uint64
_io *kaitai.Stream
_root *Bson
_parent *Bson_Element
}
func NewBson_F16() *Bson_F16 {
return &Bson_F16{
}
}
func (this *Bson_F16) Read(io *kaitai.Stream, parent *Bson_Element, root *Bson) (err error) {
this._io = io
this._parent = parent
this._root = root
tmp47, err := this._io.ReadBitsIntBe(1)
if err != nil {
return err
}
this.Str = tmp47 != 0
tmp48, err := this._io.ReadBitsIntBe(15)
if err != nil {
return err
}
this.Exponent = tmp48
tmp49, err := this._io.ReadBitsIntBe(49)
if err != nil {
return err
}
this.SignificandHi = tmp49
this._io.AlignToByte()
tmp50, err := this._io.ReadU8le()
if err != nil {
return err
}
this.SignificandLo = uint64(tmp50)
return err
}
/**
* https://docs.mongodb.com/manual/reference/method/ObjectId/
*/
type Bson_ObjectId struct {
EpochTime uint32
MachineId *Bson_U3
ProcessId uint16
Counter *Bson_U3
_io *kaitai.Stream
_root *Bson
_parent interface{}
}
func NewBson_ObjectId() *Bson_ObjectId {
return &Bson_ObjectId{
}
}
func (this *Bson_ObjectId) Read(io *kaitai.Stream, parent interface{}, root *Bson) (err error) {
this._io = io
this._parent = parent
this._root = root
tmp51, err := this._io.ReadU4le()
if err != nil {
return err
}
this.EpochTime = uint32(tmp51)
tmp52 := NewBson_U3()
err = tmp52.Read(this._io, this, this._root)
if err != nil {
return err
}
this.MachineId = tmp52
tmp53, err := this._io.ReadU2le()
if err != nil {
return err
}
this.ProcessId = uint16(tmp53)
tmp54 := NewBson_U3()
err = tmp54.Read(this._io, this, this._root)
if err != nil {
return err
}
this.Counter = tmp54
return err
}
/**
* seconds since the Unix epoch
*/
/**
* counter, starting with a random value.
*/
type Bson_RegEx struct {
Pattern *Bson_Cstring
Options *Bson_Cstring
_io *kaitai.Stream
_root *Bson
_parent *Bson_Element
}
func NewBson_RegEx() *Bson_RegEx {
return &Bson_RegEx{
}
}
func (this *Bson_RegEx) Read(io *kaitai.Stream, parent *Bson_Element, root *Bson) (err error) {
this._io = io
this._parent = parent
this._root = root
tmp55 := NewBson_Cstring()
err = tmp55.Read(this._io, this, this._root)
if err != nil {
return err
}
this.Pattern = tmp55
tmp56 := NewBson_Cstring()
err = tmp56.Read(this._io, this, this._root)
if err != nil {
return err
}
this.Options = tmp56
return err
} | bson/src/go/bson.go | 0.716814 | 0.567038 | bson.go | starcoder |
package dsu
type node struct {
value interface{}
parent *node
size int
}
// DSU is the type used to the Disjoint Set data structure.
// it maps from a value to a node pointer corresponding to the element in the set.
type DSU struct {
nodes map[interface{}]*node
}
// New returns a pointer to an empty initialized DSU instance.
func New() *DSU {
return &DSU{map[interface{}]*node{}}
}
// Contains checks if a given element is present in the disjoint set.
func (d *DSU) Contains(x interface{}) bool {
_, ok := d.nodes[x]
return ok
}
// Add takes an element as a parameter and inserts it in the disjoint set.
// If the element already exists in the set, then nothing is done,
// and the return is false
// otherwise returns true
func (d *DSU) Add(x interface{}) bool {
if d.Contains(x) {
return false
}
d.nodes[x] = &node{value: x, parent: nil, size: 1}
return true
}
// Find returns the root element that represents the set to which x belongs to.
// If the element doesn't exist in the set, Find returns the nil value.
func (d *DSU) Find(x interface{}) interface{} {
if !d.Contains(x) {
return nil
}
node := d.nodes[x]
if node.parent == nil {
return x
}
d.Find(node.parent.value)
if node.parent.parent != nil {
node.parent = node.parent.parent
}
return node.parent.value
}
// Union replaces the set containing x and the set containing y with their union.
// Union uses Find to determine the roots of the trees containing x and y.
// If the roots are the same of one of the elements doesn't exist in the set,
// there is nothing more to do. and Union returns false
// Otherwise, the two sets get be merged. This is done by either setting
// the parent element of the element with the smaller size to the other parent
// and the return of the function in this case is true
func (d *DSU) Union(x, y interface{}) bool {
if !d.Contains(x) || !d.Contains(y) {
return false
}
if d.Find(x) == d.Find(y) {
return false
}
nodex := d.nodes[d.Find(x)]
nodey := d.nodes[d.Find(y)]
if nodex.size > nodey.size {
nodey.parent = nodex
nodex.size += nodey.size
} else {
nodex.parent = nodey
nodey.size += nodex.size
}
return true
} | dsu.go | 0.817938 | 0.494568 | dsu.go | starcoder |
package common
import (
"math"
"math/rand"
"strconv"
"strings"
"time"
)
func init() {
rand.Seed(time.Now().UnixNano())
}
// Calculate seconds of one day
func GetOneDaySeconds(convertDate string) int64 {
dd, _ := time.Parse("20060102", convertDate)
return dd.Unix()
}
func GetRandNumber(avgNum float64, randSeed float64) float64 {
return avgNum - randSeed/2 + rand.Float64()*randSeed
}
// Get certain precision of float
func Round(f float64, n int) (result float64) {
pow10Num := math.Pow10(n)
s := strconv.FormatFloat(f, 'f', 10, 64)
sf, _ := strconv.ParseFloat(s, 64)
index := strings.Index(s, ".")
roundType := 0
for i := index + n + 1; i < len(s); i++ {
// according to ASCII, 0 is 48, and growing by number adding
if s[i] >= 53 {
roundType = 1
break
} else if s[i] < 52 {
break
}
}
if roundType == 1 {
return math.Ceil(sf*pow10Num) / pow10Num
}
return math.Floor(sf*pow10Num) / pow10Num
}
// Get values of per-hour in on day
func GetPerHourValues() ([24]float64, float64) {
var (
hours [24]float64
total float64
)
for i := 0; i < 24; i++ {
if i < 2 {
hours[i] = Round(5 + rand.Float64() * 4, 2)
} else if i < 7 {
hours[i] = Round(2.5 + rand.Float64() * 3, 2)
} else if i < 10 {
hours[i] = Round(4 + rand.Float64() * 5, 2)
} else if i < 13 {
hours[i] = Round(6.5 + rand.Float64() * 5, 2)
} else if i < 16 {
hours[i] = Round(8.5 + rand.Float64() * 5, 2)
} else if i < 17 {
hours[i] = Round(11 + rand.Float64() * 2, 2)
} else if i < 21 {
hours[i] = Round(13 + rand.Float64() * 5, 2)
} else if i < 23 {
hours[i] = Round(10 + rand.Float64() * 4, 2)
} else {
hours[i] = Round(7 + rand.Float64() * 5, 2)
}
total += hours[i]
}
return hours, total
}
// Get imei
// iType: 0-android, 1-ios
func GetRandImeiString(strLength int, iType int) (imei string) {
seedStr := "0123456789"
if iType == 0 {
seedStr += "abcdef"
} else {
seedStr += "ABCDEF"
}
for i := 0; i < strLength; i++ {
if i == 8 || i == 12 || i == 16 || i == 20 {
imei += "-"
}
imei += string(seedStr[rand.Intn(len(seedStr))])
}
return
}
// Get next month
func AddOneMonth(yearMonth string) string {
m, _ := strconv.Atoi(yearMonth[4:])
if m == 12 {
y, _ := strconv.Atoi(yearMonth[0:4])
return strconv.Itoa(y+1) + "01"
}
position := 5
if m >= 9 {
position = 4
}
return yearMonth[0:position] + strconv.Itoa(m+1)
}
// Get next day
func AddOneDay(convertDate string) string {
dd, _ := time.Parse("20060102", convertDate)
nextDay := dd.AddDate(0, 0, 1)
return nextDay.Format("20060102")
}
// Calculate days of one month
func CalDaysOfMonth(convertDate string) int64 {
dd, _ := time.Parse("20060102", convertDate)
lastDay := dd.AddDate(0, 0, -1)
_, _, days := lastDay.Date()
return int64(days)
}
func CheckErr(err error) {
if err != nil {
panic(err)
}
} | common.go | 0.521227 | 0.443058 | common.go | starcoder |
package unit
import "github.com/chippydip/go-sc2ai/api"
func String(e api.UnitTypeID) string {
return strings[uint32(e)]
}
var strings = map[uint32]string{
0: "Invalid",
197: "Neutral_AberrationACGluescreenDummy",
1990: "Neutral_AccelerationZoneFlyingLarge",
1989: "Neutral_AccelerationZoneFlyingMedium",
1988: "Neutral_AccelerationZoneFlyingSmall",
1987: "Neutral_AccelerationZoneLarge",
1986: "Neutral_AccelerationZoneMedium",
1985: "Neutral_AccelerationZoneSmall",
1856: "Neutral_AdeptFenixACGluescreenDummy",
660: "Neutral_Anteplott",
216: "Neutral_ArchonACGluescreenDummy",
2021: "Neutral_ArtilleryMengskACGluescreenDummy",
659: "Neutral_Artosilope",
2: "Neutral_Ball",
195: "Neutral_BanelingACGluescreenDummy",
160: "Neutral_BansheeACGluescreenDummy",
886: "Neutral_BattleStationMineralField",
887: "Neutral_BattleStationMineralField750",
161: "Neutral_BattlecruiserACGluescreenDummy",
2018: "Neutral_BattlecruiserMengskACGluescreenDummy",
297: "Neutral_BeaconArmy",
298: "Neutral_BeaconAttack",
302: "Neutral_BeaconAuto",
305: "Neutral_BeaconClaim",
307: "Neutral_BeaconCustom1",
308: "Neutral_BeaconCustom2",
309: "Neutral_BeaconCustom3",
310: "Neutral_BeaconCustom4",
299: "Neutral_BeaconDefend",
303: "Neutral_BeaconDetect",
306: "Neutral_BeaconExpand",
300: "Neutral_BeaconHarass",
301: "Neutral_BeaconIdle",
296: "Neutral_BeaconRally",
304: "Neutral_BeaconScout",
888: "Neutral_Beacon_Nova",
889: "Neutral_Beacon_NovaSmall",
315: "Neutral_Beacon_Protoss",
316: "Neutral_Beacon_ProtossSmall",
317: "Neutral_Beacon_Terran",
318: "Neutral_Beacon_TerranSmall",
319: "Neutral_Beacon_Zerg",
320: "Neutral_Beacon_ZergSmall",
200: "Neutral_BileLauncherACGluescreenDummy",
253: "Neutral_BlackOpsMissileTurretACGluescreenDummy",
176: "Neutral_BlasterBillyACGluescreenDummy",
2012: "Neutral_BlimpMengskACGluescreenDummy",
362: "Neutral_BraxisAlphaDestructible1x1",
363: "Neutral_BraxisAlphaDestructible2x2",
184: "Neutral_BroodLordACGluescreenDummy",
210: "Neutral_BrutaliskACGluescreenDummy",
163: "Neutral_BunkerACGluescreenDummy",
2019: "Neutral_BunkerDepotMengskACGluescreenDummy",
164: "Neutral_BunkerUpgradedACGluescreenDummy",
239: "Neutral_CarrierACGluescreenDummy",
240: "Neutral_CarrierAiurACGluescreenDummy",
1862: "Neutral_CarrierFenixACGluescreenDummy",
322: "Neutral_CarrionBird",
612: "Neutral_CleaningBot",
747: "Neutral_CollapsiblePurifierTowerDebris",
882: "Neutral_CollapsiblePurifierTowerDiagonal",
798: "Neutral_CollapsiblePurifierTowerPushUnit",
609: "Neutral_CollapsibleRockTower",
490: "Neutral_CollapsibleRockTowerDebris",
518: "Neutral_CollapsibleRockTowerDebrisRampLeft",
2036: "Neutral_CollapsibleRockTowerDebrisRampLeftGreen",
517: "Neutral_CollapsibleRockTowerDebrisRampRight",
2037: "Neutral_CollapsibleRockTowerDebrisRampRightGreen",
588: "Neutral_CollapsibleRockTowerDiagonal",
561: "Neutral_CollapsibleRockTowerPushUnit",
564: "Neutral_CollapsibleRockTowerPushUnitRampLeft",
2038: "Neutral_CollapsibleRockTowerPushUnitRampLeftGreen",
563: "Neutral_CollapsibleRockTowerPushUnitRampRight",
2039: "Neutral_CollapsibleRockTowerPushUnitRampRightGreen",
664: "Neutral_CollapsibleRockTowerRampLeft",
2040: "Neutral_CollapsibleRockTowerRampLeftGreen",
663: "Neutral_CollapsibleRockTowerRampRight",
2041: "Neutral_CollapsibleRockTowerRampRightGreen",
610: "Neutral_CollapsibleTerranTower",
485: "Neutral_CollapsibleTerranTowerDebris",
589: "Neutral_CollapsibleTerranTowerDiagonal",
562: "Neutral_CollapsibleTerranTowerPushUnit",
559: "Neutral_CollapsibleTerranTowerPushUnitRampLeft",
560: "Neutral_CollapsibleTerranTowerPushUnitRampRight",
590: "Neutral_CollapsibleTerranTowerRampLeft",
591: "Neutral_CollapsibleTerranTowerRampRight",
236: "Neutral_ColossusACGluescreenDummy",
1858: "Neutral_ColossusFenixACGluescreenDummy",
237: "Neutral_ColossusPurifierACGluescreenDummy",
259: "Neutral_ColossusTaldarimACGluescreenDummy",
331: "Neutral_CommentatorBot1",
332: "Neutral_CommentatorBot2",
333: "Neutral_CommentatorBot3",
334: "Neutral_CommentatorBot4",
683: "Neutral_CompoundMansion_DoorE",
684: "Neutral_CompoundMansion_DoorELowered",
679: "Neutral_CompoundMansion_DoorN",
681: "Neutral_CompoundMansion_DoorNE",
682: "Neutral_CompoundMansion_DoorNELowered",
680: "Neutral_CompoundMansion_DoorNLowered",
685: "Neutral_CompoundMansion_DoorNW",
686: "Neutral_CompoundMansion_DoorNWLowered",
199: "Neutral_CorruptorACGluescreenDummy",
227: "Neutral_CorsairACGluescreenDummy",
251: "Neutral_CovertBansheeACGluescreenDummy",
338: "Neutral_Cow",
662: "Neutral_Crabeetle",
387: "Neutral_CreepBlocker1x1",
623: "Neutral_CreepBlocker4x4",
883: "Neutral_CreepOnlyBlocker4x4",
1873: "Neutral_CreeperHostACGluescreenDummy",
168: "Neutral_CycloneACGluescreenDummy",
231: "Neutral_DarkArchonACGluescreenDummy",
232: "Neutral_DarkPylonACGluescreenDummy",
226: "Neutral_DarkTemplarShakurasACGluescreenDummy",
475: "Neutral_Debris2x2NonConjoined",
486: "Neutral_DebrisRampLeft",
487: "Neutral_DebrisRampRight",
654: "Neutral_DesertPlanetSearchlight",
655: "Neutral_DesertPlanetStreetlight",
351: "Neutral_DestructibleBillboardScrollingText",
350: "Neutral_DestructibleBillboardTall",
346: "Neutral_DestructibleBullhornLights",
625: "Neutral_DestructibleCityDebris2x4Horizontal",
624: "Neutral_DestructibleCityDebris2x4Vertical",
627: "Neutral_DestructibleCityDebris2x6Horizontal",
626: "Neutral_DestructibleCityDebris2x6Vertical",
628: "Neutral_DestructibleCityDebris4x4",
629: "Neutral_DestructibleCityDebris6x6",
630: "Neutral_DestructibleCityDebrisHugeDiagonalBLUR",
631: "Neutral_DestructibleCityDebrisHugeDiagonalULBR",
364: "Neutral_DestructibleDebris4x4",
365: "Neutral_DestructibleDebris6x6",
377: "Neutral_DestructibleDebrisRampDiagonalHugeBLUR",
376: "Neutral_DestructibleDebrisRampDiagonalHugeULBR",
836: "Neutral_DestructibleExpeditionGate6x6",
358: "Neutral_DestructibleGarage",
359: "Neutral_DestructibleGarageLarge",
645: "Neutral_DestructibleIce2x4Horizontal",
644: "Neutral_DestructibleIce2x4Vertical",
647: "Neutral_DestructibleIce2x6Horizontal",
646: "Neutral_DestructibleIce2x6Vertical",
648: "Neutral_DestructibleIce4x4",
649: "Neutral_DestructibleIce6x6",
651: "Neutral_DestructibleIceDiagonalHugeBLUR",
650: "Neutral_DestructibleIceDiagonalHugeULBR",
653: "Neutral_DestructibleIceHorizontalHuge",
652: "Neutral_DestructibleIceVerticalHuge",
373: "Neutral_DestructibleRampDiagonalHugeBLUR",
372: "Neutral_DestructibleRampDiagonalHugeULBR",
375: "Neutral_DestructibleRampHorizontalHuge",
374: "Neutral_DestructibleRampVerticalHuge",
367: "Neutral_DestructibleRock2x4Horizontal",
366: "Neutral_DestructibleRock2x4Vertical",
369: "Neutral_DestructibleRock2x6Horizontal",
368: "Neutral_DestructibleRock2x6Vertical",
370: "Neutral_DestructibleRock4x4",
371: "Neutral_DestructibleRock6x6",
613: "Neutral_DestructibleRock6x6Weak",
635: "Neutral_DestructibleRockEx12x4Horizontal",
634: "Neutral_DestructibleRockEx12x4Vertical",
637: "Neutral_DestructibleRockEx12x6Horizontal",
636: "Neutral_DestructibleRockEx12x6Vertical",
638: "Neutral_DestructibleRockEx14x4",
639: "Neutral_DestructibleRockEx16x6",
641: "Neutral_DestructibleRockEx1DiagonalHugeBLUR",
640: "Neutral_DestructibleRockEx1DiagonalHugeULBR",
643: "Neutral_DestructibleRockEx1HorizontalHuge",
642: "Neutral_DestructibleRockEx1VerticalHuge",
345: "Neutral_DestructibleSearchlight",
354: "Neutral_DestructibleSignsConstruction",
353: "Neutral_DestructibleSignsDirectional",
355: "Neutral_DestructibleSignsFunny",
356: "Neutral_DestructibleSignsIcons",
357: "Neutral_DestructibleSignsWarning",
352: "Neutral_DestructibleSpacePlatformBarrier",
348: "Neutral_DestructibleSpacePlatformSign",
349: "Neutral_DestructibleStoreFrontCityProps",
347: "Neutral_DestructibleStreetlight",
360: "Neutral_DestructibleTrafficSignal",
837: "Neutral_DestructibleZergInfestation3x3",
175: "Neutral_DevastationTurretACGluescreenDummy",
208: "Neutral_DevourerACGluescreenDummy",
565: "Neutral_DigesterCreepSprayTargetUnit",
566: "Neutral_DigesterCreepSprayUnit",
1859: "Neutral_DisruptorACGluescreenDummy",
336: "Neutral_Dog",
214: "Neutral_DragoonACGluescreenDummy",
2042: "Neutral_DummyUnit000",
2043: "Neutral_DummyUnit001",
2044: "Neutral_DummyUnit002",
2045: "Neutral_DummyUnit003",
2046: "Neutral_DummyUnit004",
2047: "Neutral_DummyUnit005",
2048: "Neutral_DummyUnit006",
2049: "Neutral_DummyUnit007",
2050: "Neutral_DummyUnit008",
2051: "Neutral_DummyUnit009",
2052: "Neutral_DummyUnit010",
2053: "Neutral_DummyUnit011",
2054: "Neutral_DummyUnit012",
2055: "Neutral_DummyUnit013",
2056: "Neutral_DummyUnit014",
243: "Neutral_EliteMarineACGluescreenDummy",
480: "Neutral_EnemyPathingBlocker16x16",
476: "Neutral_EnemyPathingBlocker1x1",
477: "Neutral_EnemyPathingBlocker2x2",
478: "Neutral_EnemyPathingBlocker4x4",
479: "Neutral_EnemyPathingBlocker8x8",
1867: "Neutral_FireRoachACGluescreenDummy",
154: "Neutral_FirebatACGluescreenDummy",
174: "Neutral_FlamingBettyACGluescreenDummy",
854: "Neutral_FlyoverUnit",
2014: "Neutral_GhostMengskACGluescreenDummy",
382: "Neutral_GlobeStatue",
167: "Neutral_GoliathACGluescreenDummy",
207: "Neutral_GuardianACGluescreenDummy",
1882: "Neutral_HHBattlecruiserACGluescreenDummy",
1884: "Neutral_HHBomberPlatformACGluescreenDummy",
1879: "Neutral_HHHellionTankACGluescreenDummy",
1885: "Neutral_HHMercStarportACGluescreenDummy",
1886: "Neutral_HHMissileTurretACGluescreenDummy",
1883: "Neutral_HHRavenACGluescreenDummy",
1877: "Neutral_HHReaperACGluescreenDummy",
1881: "Neutral_HHVikingACGluescreenDummy",
1878: "Neutral_HHWidowMineACGluescreenDummy",
1880: "Neutral_HHWraithACGluescreenDummy",
248: "Neutral_HeavySiegeTankACGluescreenDummy",
166: "Neutral_HellbatACGluescreenDummy",
246: "Neutral_HellbatRangerACGluescreenDummy",
394: "Neutral_HelperEmitterSelectionArrow",
171: "Neutral_HerculesACGluescreenDummy",
215: "Neutral_HighTemplarACGluescreenDummy",
257: "Neutral_HighTemplarTaldarimACGluescreenDummy",
181: "Neutral_HydraliskACGluescreenDummy",
182: "Neutral_HydraliskLurkerACGluescreenDummy",
592: "Neutral_Ice2x2NonConjoined",
217: "Neutral_ImmortalACGluescreenDummy",
1857: "Neutral_ImmortalFenixACGluescreenDummy",
235: "Neutral_ImmortalKaraxACGluescreenDummy",
258: "Neutral_ImmortalTaldarimACGluescreenDummy",
1920: "Neutral_InfestorEnsnareAttackMissile",
1993: "Neutral_InhibitorZoneFlyingLarge",
1992: "Neutral_InhibitorZoneFlyingMedium",
1991: "Neutral_InhibitorZoneFlyingSmall",
1984: "Neutral_InhibitorZoneLarge",
1983: "Neutral_InhibitorZoneMedium",
1982: "Neutral_InhibitorZoneSmall",
607: "Neutral_InvisibleTargetDummy",
324: "Neutral_KarakFemale",
323: "Neutral_KarakMale",
241: "Neutral_KhaydarinMonolithACGluescreenDummy",
661: "Neutral_LabBot",
665: "Neutral_LabMineralField",
666: "Neutral_LabMineralField750",
211: "Neutral_LeviathanACGluescreenDummy",
2022: "Neutral_LoadOutSpray@1",
2031: "Neutral_LoadOutSpray@10",
2032: "Neutral_LoadOutSpray@11",
2033: "Neutral_LoadOutSpray@12",
2034: "Neutral_LoadOutSpray@13",
2035: "Neutral_LoadOutSpray@14",
2023: "Neutral_LoadOutSpray@2",
2024: "Neutral_LoadOutSpray@3",
2025: "Neutral_LoadOutSpray@4",
2026: "Neutral_LoadOutSpray@5",
2027: "Neutral_LoadOutSpray@6",
2028: "Neutral_LoadOutSpray@7",
2029: "Neutral_LoadOutSpray@8",
2030: "Neutral_LoadOutSpray@9",
799: "Neutral_LocustMPPrecursor",
188: "Neutral_LurkerACGluescreenDummy",
321: "Neutral_Lyote",
156: "Neutral_MarauderACGluescreenDummy",
244: "Neutral_MarauderCommandoACGluescreenDummy",
2013: "Neutral_MarauderMengskACGluescreenDummy",
153: "Neutral_MarineACGluescreenDummy",
2000: "Neutral_MechaBanelingACGluescreenDummy",
2007: "Neutral_MechaBattlecarrierLordACGluescreenDummy",
2003: "Neutral_MechaCorruptorACGluescreenDummy",
2001: "Neutral_MechaHydraliskACGluescreenDummy",
2002: "Neutral_MechaInfestorACGluescreenDummy",
2006: "Neutral_MechaLurkerACGluescreenDummy",
2005: "Neutral_MechaOverseerACGluescreenDummy",
2008: "Neutral_MechaSpineCrawlerACGluescreenDummy",
2009: "Neutral_MechaSporeCrawlerACGluescreenDummy",
2004: "Neutral_MechaUltraliskACGluescreenDummy",
1999: "Neutral_MechaZerglingACGluescreenDummy",
155: "Neutral_MedicACGluescreenDummy",
2011: "Neutral_MedivacMengskACGluescreenDummy",
380: "Neutral_MengskStatue",
379: "Neutral_MengskStatueAlone",
341: "Neutral_MineralField",
1996: "Neutral_MineralField450",
483: "Neutral_MineralField750",
1997: "Neutral_MineralFieldOpaque",
1998: "Neutral_MineralFieldOpaque900",
165: "Neutral_MissileTurretACGluescreenDummy",
2020: "Neutral_MissileTurretMengskACGluescreenDummy",
839: "Neutral_Moopy",
395: "Neutral_MultiKillObject",
206: "Neutral_MutaliskACGluescreenDummy",
183: "Neutral_MutaliskBroodlordACGluescreenDummy",
262: "Neutral_NeedleSpinesWeapon",
191: "Neutral_NydusNetworkACGluescreenDummy",
218: "Neutral_ObserverACGluescreenDummy",
1860: "Neutral_ObserverFenixACGluescreenDummy",
192: "Neutral_OmegaNetworkACGluescreenDummy",
230: "Neutral_OracleACGluescreenDummy",
162: "Neutral_OrbitalCommandACGluescreenDummy",
378: "Neutral_OverlordGenerateCreepKeybind",
187: "Neutral_OverseerACGluescreenDummy",
1844: "Neutral_OverseerZagaraACGluescreenDummy",
1942: "Neutral_ParasiticBombRelayDummy",
389: "Neutral_PathingBlocker1x1",
390: "Neutral_PathingBlocker2x2",
633: "Neutral_PathingBlockerRadius1",
173: "Neutral_PerditionTurretACGluescreenDummy",
388: "Neutral_PermanentCreepBlocker1x1",
219: "Neutral_PhoenixAiurACGluescreenDummy",
238: "Neutral_PhoenixPurifierACGluescreenDummy",
222: "Neutral_PhotonCannonACGluescreenDummy",
1863: "Neutral_PhotonCannonFenixACGluescreenDummy",
261: "Neutral_PhotonCannonTaldarimACGluescreenDummy",
615: "Neutral_PhysicsCapsule",
616: "Neutral_PhysicsCube",
617: "Neutral_PhysicsCylinder",
618: "Neutral_PhysicsKnot",
619: "Neutral_PhysicsL",
620: "Neutral_PhysicsPrimitives",
621: "Neutral_PhysicsSphere",
622: "Neutral_PhysicsStar",
596: "Neutral_PickupPalletGas",
597: "Neutral_PickupPalletMinerals",
598: "Neutral_PickupScrapSalvage1x1",
599: "Neutral_PickupScrapSalvage2x2",
600: "Neutral_PickupScrapSalvage3x3",
1868: "Neutral_PrimalGuardianACGluescreenDummy",
1869: "Neutral_PrimalHydraliskACGluescreenDummy",
1871: "Neutral_PrimalImpalerACGluescreenDummy",
1870: "Neutral_PrimalMutaliskACGluescreenDummy",
1866: "Neutral_PrimalRoachACGluescreenDummy",
1872: "Neutral_PrimalSwarmHostACGluescreenDummy",
1874: "Neutral_PrimalUltraliskACGluescreenDummy",
1876: "Neutral_PrimalWurmACGluescreenDummy",
1864: "Neutral_PrimalZerglingACGluescreenDummy",
614: "Neutral_ProtossSnakeSegmentDemo",
608: "Neutral_ProtossVespeneGeyser",
884: "Neutral_PurifierMineralField",
885: "Neutral_PurifierMineralField750",
796: "Neutral_PurifierRichMineralField",
797: "Neutral_PurifierRichMineralField750",
880: "Neutral_PurifierVespeneGeyser",
180: "Neutral_QueenCoopACGluescreenDummy",
1843: "Neutral_QueenZagaraACGluescreenDummy",
249: "Neutral_RaidLiberatorACGluescreenDummy",
252: "Neutral_RailgunTurretACGluescreenDummy",
179: "Neutral_RaptorACGluescreenDummy",
204: "Neutral_RavagerACGluescreenDummy",
1865: "Neutral_RavasaurACGluescreenDummy",
250: "Neutral_RavenTypeIIACGluescreenDummy",
220: "Neutral_ReaverACGluescreenDummy",
123: "Neutral_RedstoneLavaCritter",
121: "Neutral_RedstoneLavaCritterBurrowed",
124: "Neutral_RedstoneLavaCritterInjured",
122: "Neutral_RedstoneLavaCritterInjuredBurrowed",
877: "Neutral_ReptileCrate",
146: "Neutral_RichMineralField",
147: "Neutral_RichMineralField750",
344: "Neutral_RichVespeneGeyser",
202: "Neutral_RoachACGluescreenDummy",
203: "Neutral_RoachVileACGluescreenDummy",
312: "Neutral_Rocks2x2NonConjoined",
601: "Neutral_RoughTerrain",
1850: "Neutral_SILiberatorACGluescreenDummy",
1921: "Neutral_SNARE_PLACEHOLDER",
335: "Neutral_Scantipede",
170: "Neutral_ScienceVesselACGluescreenDummy",
198: "Neutral_ScourgeACGluescreenDummy",
1861: "Neutral_ScoutACGluescreenDummy",
482: "Neutral_SentryACGluescreenDummy",
1855: "Neutral_SentryFenixACGluescreenDummy",
234: "Neutral_SentryPurifierACGluescreenDummy",
256: "Neutral_SentryTaldarimACGluescreenDummy",
881: "Neutral_ShakurasVespeneGeyser",
410: "Neutral_Shape4PointStar",
411: "Neutral_Shape5PointStar",
412: "Neutral_Shape6PointStar",
413: "Neutral_Shape8PointStar",
462: "Neutral_ShapeApple",
414: "Neutral_ShapeArrowPointer",
461: "Neutral_ShapeBanana",
459: "Neutral_ShapeBaseball",
460: "Neutral_ShapeBaseballBat",
456: "Neutral_ShapeBasketball",
415: "Neutral_ShapeBowl",
416: "Neutral_ShapeBox",
417: "Neutral_ShapeCapsule",
457: "Neutral_ShapeCarrot",
463: "Neutral_ShapeCashLarge",
464: "Neutral_ShapeCashMedium",
465: "Neutral_ShapeCashSmall",
458: "Neutral_ShapeCherry",
397: "Neutral_ShapeCone",
418: "Neutral_ShapeCrescentMoon",
398: "Neutral_ShapeCube",
399: "Neutral_ShapeCylinder",
419: "Neutral_ShapeDecahedron",
420: "Neutral_ShapeDiamond",
400: "Neutral_ShapeDodecahedron",
455: "Neutral_ShapeDollarSign",
429: "Neutral_ShapeEgg",
454: "Neutral_ShapeEuroSign",
421: "Neutral_ShapeFootball",
466: "Neutral_ShapeFootballColored",
422: "Neutral_ShapeGemstone",
452: "Neutral_ShapeGolfClub",
396: "Neutral_ShapeGolfball",
453: "Neutral_ShapeGrape",
451: "Neutral_ShapeHand",
423: "Neutral_ShapeHeart",
450: "Neutral_ShapeHockeyPuck",
449: "Neutral_ShapeHockeyStick",
448: "Neutral_ShapeHorseshoe",
401: "Neutral_ShapeIcosahedron",
424: "Neutral_ShapeJack",
446: "Neutral_ShapeLemon",
467: "Neutral_ShapeLemonSmall",
447: "Neutral_ShapeMoneyBag",
445: "Neutral_ShapeO",
402: "Neutral_ShapeOctahedron",
443: "Neutral_ShapeOrange",
468: "Neutral_ShapeOrangeSmall",
444: "Neutral_ShapePeanut",
441: "Neutral_ShapePear",
442: "Neutral_ShapePineapple",
425: "Neutral_ShapePlusSign",
440: "Neutral_ShapePoundSign",
403: "Neutral_ShapePyramid",
438: "Neutral_ShapeRainbow",
404: "Neutral_ShapeRoundedCube",
439: "Neutral_ShapeSadFace",
426: "Neutral_ShapeShamrock",
436: "Neutral_ShapeSmileyFace",
437: "Neutral_ShapeSoccerball",
427: "Neutral_ShapeSpade",
405: "Neutral_ShapeSphere",
435: "Neutral_ShapeStrawberry",
434: "Neutral_ShapeTennisball",
406: "Neutral_ShapeTetrahedron",
407: "Neutral_ShapeThickTorus",
408: "Neutral_ShapeThinTorus",
409: "Neutral_ShapeTorus",
470: "Neutral_ShapeTreasureChestClosed",
469: "Neutral_ShapeTreasureChestOpen",
428: "Neutral_ShapeTube",
432: "Neutral_ShapeWatermelon",
471: "Neutral_ShapeWatermelonSmall",
433: "Neutral_ShapeWonSign",
431: "Neutral_ShapeX",
430: "Neutral_ShapeYenSign",
337: "Neutral_Sheep",
242: "Neutral_ShieldBatteryACGluescreenDummy",
158: "Neutral_SiegeTankACGluescreenDummy",
2015: "Neutral_SiegeTankMengskACGluescreenDummy",
879: "Neutral_SlaynElemental",
833: "Neutral_SlaynElementalGrabAirUnit",
834: "Neutral_SlaynElementalGrabGroundUnit",
832: "Neutral_SlaynElementalGrabWeapon",
835: "Neutral_SlaynElementalWeapon",
878: "Neutral_SlaynSwarmHostSpawnFlyer",
1909: "Neutral_SnowGlazeStarterMP",
343: "Neutral_SpacePlatformGeyser",
245: "Neutral_SpecOpsGhostACGluescreenDummy",
189: "Neutral_SpineCrawlerACGluescreenDummy",
177: "Neutral_SpinningDizzyACGluescreenDummy",
196: "Neutral_SplitterlingACGluescreenDummy",
190: "Neutral_SporeCrawlerACGluescreenDummy",
225: "Neutral_StalkerShakurasACGluescreenDummy",
255: "Neutral_StalkerTaldarimACGluescreenDummy",
3: "Neutral_StereoscopicOptionsUnit",
247: "Neutral_StrikeGoliathACGluescreenDummy",
1853: "Neutral_StukovBroodQueenACGluescreenDummy",
1849: "Neutral_StukovInfestedBansheeACGluescreenDummy",
1851: "Neutral_StukovInfestedBunkerACGluescreenDummy",
1845: "Neutral_StukovInfestedCivilianACGluescreenDummy",
1848: "Neutral_StukovInfestedDiamondbackACGluescreenDummy",
1846: "Neutral_StukovInfestedMarineACGluescreenDummy",
1852: "Neutral_StukovInfestedMissileTurretACGluescreenDummy",
1847: "Neutral_StukovInfestedSiegeTankACGluescreenDummy",
1892: "Neutral_StukovInfestedTrooperACGluescreenDummy",
254: "Neutral_SupplicantACGluescreenDummy",
205: "Neutral_SwarmHostACGluescreenDummy",
201: "Neutral_SwarmQueenACGluescreenDummy",
194: "Neutral_SwarmlingACGluescreenDummy",
1: "Neutral_System_Snapshot_Dummy",
675: "Neutral_Tarsonis_DoorE",
676: "Neutral_Tarsonis_DoorELowered",
671: "Neutral_Tarsonis_DoorN",
673: "Neutral_Tarsonis_DoorNE",
674: "Neutral_Tarsonis_DoorNELowered",
672: "Neutral_Tarsonis_DoorNLowered",
677: "Neutral_Tarsonis_DoorNW",
678: "Neutral_Tarsonis_DoorNWLowered",
221: "Neutral_TempestACGluescreenDummy",
172: "Neutral_ThorACGluescreenDummy",
2016: "Neutral_ThorMengskACGluescreenDummy",
611: "Neutral_ThornLizard",
186: "Neutral_TorrasqueACGluescreenDummy",
361: "Neutral_TrafficSignal",
2010: "Neutral_TrooperMengskACGluescreenDummy",
1923: "Neutral_TychusFirebatACGluescreenDummy",
1929: "Neutral_TychusGhostACGluescreenDummy",
1928: "Neutral_TychusHERCACGluescreenDummy",
1926: "Neutral_TychusMarauderACGluescreenDummy",
1925: "Neutral_TychusMedicACGluescreenDummy",
1922: "Neutral_TychusReaperACGluescreenDummy",
1930: "Neutral_TychusSCVAutoTurretACGluescreenDummy",
1924: "Neutral_TychusSpectreACGluescreenDummy",
1927: "Neutral_TychusWarhoundACGluescreenDummy",
1875: "Neutral_TyrannozorACGluescreenDummy",
185: "Neutral_UltraliskACGluescreenDummy",
473: "Neutral_UnbuildableBricksDestructible",
602: "Neutral_UnbuildableBricksSmallUnit",
656: "Neutral_UnbuildableBricksUnit",
474: "Neutral_UnbuildablePlatesDestructible",
603: "Neutral_UnbuildablePlatesSmallUnit",
604: "Neutral_UnbuildablePlatesUnit",
472: "Neutral_UnbuildableRocksDestructible",
605: "Neutral_UnbuildableRocksSmallUnit",
657: "Neutral_UnbuildableRocksUnit",
328: "Neutral_UrsadakCalf",
327: "Neutral_UrsadakFemale",
325: "Neutral_UrsadakFemaleExotic",
326: "Neutral_UrsadakMale",
329: "Neutral_UrsadakMaleExotic",
148: "Neutral_Ursadon",
890: "Neutral_Ursula",
330: "Neutral_UtilityBot",
342: "Neutral_VespeneGeyser",
159: "Neutral_VikingACGluescreenDummy",
2017: "Neutral_VikingMengskACGluescreenDummy",
209: "Neutral_ViperACGluescreenDummy",
228: "Neutral_VoidRayACGluescreenDummy",
229: "Neutral_VoidRayShakurasACGluescreenDummy",
157: "Neutral_VultureACGluescreenDummy",
260: "Neutral_WarpPrismTaldarimACGluescreenDummy",
381: "Neutral_WolfStatue",
169: "Neutral_WraithACGluescreenDummy",
1895: "Neutral_XelNagaDestructibleBlocker6E",
1897: "Neutral_XelNagaDestructibleBlocker6N",
1896: "Neutral_XelNagaDestructibleBlocker6NE",
1898: "Neutral_XelNagaDestructibleBlocker6NW",
1893: "Neutral_XelNagaDestructibleBlocker6S",
1894: "Neutral_XelNagaDestructibleBlocker6SE",
1900: "Neutral_XelNagaDestructibleBlocker6SW",
1899: "Neutral_XelNagaDestructibleBlocker6W",
1903: "Neutral_XelNagaDestructibleBlocker8E",
1905: "Neutral_XelNagaDestructibleBlocker8N",
1904: "Neutral_XelNagaDestructibleBlocker8NE",
1906: "Neutral_XelNagaDestructibleBlocker8NW",
1901: "Neutral_XelNagaDestructibleBlocker8S",
1902: "Neutral_XelNagaDestructibleBlocker8SE",
1908: "Neutral_XelNagaDestructibleBlocker8SW",
1907: "Neutral_XelNagaDestructibleBlocker8W",
863: "Neutral_XelNagaDestructibleRampBlocker6E",
865: "Neutral_XelNagaDestructibleRampBlocker6N",
864: "Neutral_XelNagaDestructibleRampBlocker6NE",
866: "Neutral_XelNagaDestructibleRampBlocker6NW",
861: "Neutral_XelNagaDestructibleRampBlocker6S",
862: "Neutral_XelNagaDestructibleRampBlocker6SE",
868: "Neutral_XelNagaDestructibleRampBlocker6SW",
867: "Neutral_XelNagaDestructibleRampBlocker6W",
871: "Neutral_XelNagaDestructibleRampBlocker8E",
873: "Neutral_XelNagaDestructibleRampBlocker8N",
872: "Neutral_XelNagaDestructibleRampBlocker8NE",
874: "Neutral_XelNagaDestructibleRampBlocker8NW",
869: "Neutral_XelNagaDestructibleRampBlocker8S",
870: "Neutral_XelNagaDestructibleRampBlocker8SE",
876: "Neutral_XelNagaDestructibleRampBlocker8SW",
875: "Neutral_XelNagaDestructibleRampBlocker8W",
606: "Neutral_XelNagaHealingShrine",
149: "Neutral_XelNagaTower",
519: "Neutral_XelNaga_Caverns_DoorE",
520: "Neutral_XelNaga_Caverns_DoorEOpened",
521: "Neutral_XelNaga_Caverns_DoorN",
522: "Neutral_XelNaga_Caverns_DoorNE",
523: "Neutral_XelNaga_Caverns_DoorNEOpened",
524: "Neutral_XelNaga_Caverns_DoorNOpened",
525: "Neutral_XelNaga_Caverns_DoorNW",
526: "Neutral_XelNaga_Caverns_DoorNWOpened",
527: "Neutral_XelNaga_Caverns_DoorS",
528: "Neutral_XelNaga_Caverns_DoorSE",
529: "Neutral_XelNaga_Caverns_DoorSEOpened",
530: "Neutral_XelNaga_Caverns_DoorSOpened",
531: "Neutral_XelNaga_Caverns_DoorSW",
532: "Neutral_XelNaga_Caverns_DoorSWOpened",
533: "Neutral_XelNaga_Caverns_DoorW",
534: "Neutral_XelNaga_Caverns_DoorWOpened",
212: "Neutral_ZealotACGluescreenDummy",
213: "Neutral_ZealotAiurACGluescreenDummy",
1854: "Neutral_ZealotFenixACGluescreenDummy",
233: "Neutral_ZealotPurifierACGluescreenDummy",
224: "Neutral_ZealotShakurasACGluescreenDummy",
223: "Neutral_ZealotVorazunACGluescreenDummy",
1933: "Neutral_ZeratulDarkTemplarACGluescreenDummy",
1936: "Neutral_ZeratulDisruptorACGluescreenDummy",
1934: "Neutral_ZeratulImmortalACGluescreenDummy",
1935: "Neutral_ZeratulObserverACGluescreenDummy",
1938: "Neutral_ZeratulPhotonCannonACGluescreenDummy",
1932: "Neutral_ZeratulSentryACGluescreenDummy",
1931: "Neutral_ZeratulStalkerACGluescreenDummy",
1937: "Neutral_ZeratulWarpPrismACGluescreenDummy",
178: "Neutral_ZerglingKerriganACGluescreenDummy",
193: "Neutral_ZerglingZagaraACGluescreenDummy",
658: "Neutral_ZerusDestructibleArch",
311: "Protoss_Adept",
801: "Protoss_AdeptPhaseShift",
896: "Protoss_AdeptPiercingWeapon",
826: "Protoss_AdeptUpgradeWeapon",
825: "Protoss_AdeptWeapon",
857: "Protoss_ArbiterMP",
813: "Protoss_ArbiterMPWeaponMissile",
141: "Protoss_Archon",
61: "Protoss_Assimilator",
1994: "Protoss_AssimilatorRich",
79: "Protoss_Carrier",
4: "Protoss_Colossus",
855: "Protoss_CorsairMP",
72: "Protoss_CyberneticsCore",
69: "Protoss_DarkShrine",
76: "Protoss_DarkTemplar",
815: "Protoss_DevourerMPWeaponMissile",
694: "Protoss_Disruptor",
733: "Protoss_DisruptorPhased",
64: "Protoss_FleetBeacon",
135: "Protoss_ForceField",
63: "Protoss_Forge",
62: "Protoss_Gateway",
75: "Protoss_HighTemplar",
1887: "Protoss_HighTemplarSkinPreview",
1914: "Protoss_HighTemplarWeaponMissile",
593: "Protoss_IceProtossCrates",
83: "Protoss_Immortal",
85: "Protoss_Interceptor",
277: "Protoss_IonCannonsWeapon",
819: "Protoss_LightningBombWeapon",
10: "Protoss_Mothership",
488: "Protoss_MothershipCore",
579: "Protoss_MothershipCoreWeaponWeapon",
59: "Protoss_Nexus",
82: "Protoss_Observer",
1911: "Protoss_ObserverSiegeMode",
495: "Protoss_Oracle",
732: "Protoss_OracleStasisTrap",
808: "Protoss_OracleWeapon",
78: "Protoss_Phoenix",
66: "Protoss_PhotonCannon",
287: "Protoss_PhotonCannonWeapon",
84: "Protoss_Probe",
594: "Protoss_ProtossCrates",
60: "Protoss_Pylon",
894: "Protoss_PylonOvercharged",
800: "Protoss_ReleaseInterceptorsBeacon",
840: "Protoss_Replicant",
587: "Protoss_RepulsorCannonWeapon",
569: "Protoss_ResourceBlocker",
70: "Protoss_RoboticsBay",
71: "Protoss_RoboticsFacility",
856: "Protoss_ScoutMP",
811: "Protoss_ScoutMPAirWeaponLeft",
812: "Protoss_ScoutMPAirWeaponRight",
77: "Protoss_Sentry",
1910: "Protoss_ShieldBattery",
74: "Protoss_Stalker",
284: "Protoss_StalkerWeapon",
67: "Protoss_Stargate",
496: "Protoss_Tempest",
570: "Protoss_TempestWeapon",
809: "Protoss_TempestWeaponGround",
68: "Protoss_TemplarArchive",
65: "Protoss_TwilightCouncil",
725: "Protoss_VoidMPImmortalReviveCorpse",
80: "Protoss_VoidRay",
133: "Protoss_WarpGate",
81: "Protoss_WarpPrism",
136: "Protoss_WarpPrismPhasing",
1888: "Protoss_WarpPrismSkinPreview",
73: "Protoss_Zealot",
272: "Terran_ATALaserBatteryLMWeapon",
273: "Terran_ATSLaserBatteryLMWeapon",
738: "Terran_AiurLightBridgeAbandonedNE10",
737: "Terran_AiurLightBridgeAbandonedNE10Out",
740: "Terran_AiurLightBridgeAbandonedNE12",
739: "Terran_AiurLightBridgeAbandonedNE12Out",
736: "Terran_AiurLightBridgeAbandonedNE8",
735: "Terran_AiurLightBridgeAbandonedNE8Out",
744: "Terran_AiurLightBridgeAbandonedNW10",
743: "Terran_AiurLightBridgeAbandonedNW10Out",
746: "Terran_AiurLightBridgeAbandonedNW12",
745: "Terran_AiurLightBridgeAbandonedNW12Out",
742: "Terran_AiurLightBridgeAbandonedNW8",
741: "Terran_AiurLightBridgeAbandonedNW8Out",
698: "Terran_AiurLightBridgeNE10",
697: "Terran_AiurLightBridgeNE10Out",
700: "Terran_AiurLightBridgeNE12",
699: "Terran_AiurLightBridgeNE12Out",
696: "Terran_AiurLightBridgeNE8",
695: "Terran_AiurLightBridgeNE8Out",
704: "Terran_AiurLightBridgeNW10",
703: "Terran_AiurLightBridgeNW10Out",
706: "Terran_AiurLightBridgeNW12",
705: "Terran_AiurLightBridgeNW12Out",
702: "Terran_AiurLightBridgeNW8",
701: "Terran_AiurLightBridgeNW8Out",
843: "Terran_AiurTempleBridgeDestructibleNE10Out",
844: "Terran_AiurTempleBridgeDestructibleNE12Out",
842: "Terran_AiurTempleBridgeDestructibleNE8Out",
846: "Terran_AiurTempleBridgeDestructibleNW10Out",
847: "Terran_AiurTempleBridgeDestructibleNW12Out",
845: "Terran_AiurTempleBridgeDestructibleNW8Out",
852: "Terran_AiurTempleBridgeDestructibleSE10Out",
853: "Terran_AiurTempleBridgeDestructibleSE12Out",
851: "Terran_AiurTempleBridgeDestructibleSE8Out",
849: "Terran_AiurTempleBridgeDestructibleSW10Out",
850: "Terran_AiurTempleBridgeDestructibleSW12Out",
848: "Terran_AiurTempleBridgeDestructibleSW8Out",
708: "Terran_AiurTempleBridgeNE10Out",
709: "Terran_AiurTempleBridgeNE12Out",
707: "Terran_AiurTempleBridgeNE8Out",
711: "Terran_AiurTempleBridgeNW10Out",
712: "Terran_AiurTempleBridgeNW12Out",
710: "Terran_AiurTempleBridgeNW8Out",
29: "Terran_Armory",
392: "Terran_AutoTestAttackTargetAir",
391: "Terran_AutoTestAttackTargetGround",
393: "Terran_AutoTestAttacker",
31: "Terran_AutoTurret",
291: "Terran_AutoTurretReleaseWeapon",
286: "Terran_BacklashRocketsLMWeapon",
55: "Terran_Banshee",
21: "Terran_Barracks",
46: "Terran_BarracksFlying",
38: "Terran_BarracksReactor",
37: "Terran_BarracksTechLab",
57: "Terran_Battlecruiser",
24: "Terran_Bunker",
895: "Terran_BypassArmorDrone",
18: "Terran_CommandCenter",
36: "Terran_CommandCenterFlying",
692: "Terran_Cyclone",
805: "Terran_CycloneMissile",
806: "Terran_CycloneMissileLarge",
804: "Terran_CycloneMissileLargeAir",
1915: "Terran_CycloneMissileLargeAirAlternative",
275: "Terran_D8ChargeWeapon",
285: "Terran_EMP2Weapon",
891: "Terran_Elsecaro_Colonist_Hut",
22: "Terran_EngineeringBay",
510: "Terran_ExtendingBridgeNEWide10",
509: "Terran_ExtendingBridgeNEWide10Out",
514: "Terran_ExtendingBridgeNEWide12",
513: "Terran_ExtendingBridgeNEWide12Out",
506: "Terran_ExtendingBridgeNEWide8",
505: "Terran_ExtendingBridgeNEWide8Out",
512: "Terran_ExtendingBridgeNWWide10",
511: "Terran_ExtendingBridgeNWWide10Out",
516: "Terran_ExtendingBridgeNWWide12",
515: "Terran_ExtendingBridgeNWWide12Out",
508: "Terran_ExtendingBridgeNWWide8",
507: "Terran_ExtendingBridgeNWWide8Out",
27: "Terran_Factory",
43: "Terran_FactoryFlying",
40: "Terran_FactoryReactor",
39: "Terran_FactoryTechLab",
30: "Terran_FusionCore",
50: "Terran_Ghost",
26: "Terran_GhostAcademy",
144: "Terran_GhostAlternate",
145: "Terran_GhostNova",
821: "Terran_GrappleWeapon",
838: "Terran_HERC",
820: "Terran_HERCPlacement",
53: "Terran_Hellion",
484: "Terran_HellionTank",
267: "Terran_HunterSeekerWeapon",
830: "Terran_KD8Charge",
831: "Terran_KD8ChargeWeapon",
689: "Terran_Liberator",
734: "Terran_LiberatorAG",
829: "Terran_LiberatorAGMissile",
828: "Terran_LiberatorDamageMissile",
827: "Terran_LiberatorMissile",
1890: "Terran_LiberatorSkinPreview",
274: "Terran_LongboltMissileWeapon",
268: "Terran_MULE",
51: "Terran_Marauder",
48: "Terran_Marine",
54: "Terran_Medivac",
23: "Terran_MissileTurret",
58: "Terran_Nuke",
132: "Terran_OrbitalCommand",
134: "Terran_OrbitalCommandFlying",
130: "Terran_PlanetaryFortress",
11: "Terran_PointDefenseDrone",
266: "Terran_PointDefenseDroneReleaseWeapon",
785: "Terran_PortCity_Bridge_UnitE10",
784: "Terran_PortCity_Bridge_UnitE10Out",
793: "Terran_PortCity_Bridge_UnitE12",
792: "Terran_PortCity_Bridge_UnitE12Out",
777: "Terran_PortCity_Bridge_UnitE8",
776: "Terran_PortCity_Bridge_UnitE8Out",
781: "Terran_PortCity_Bridge_UnitN10",
780: "Terran_PortCity_Bridge_UnitN10Out",
789: "Terran_PortCity_Bridge_UnitN12",
788: "Terran_PortCity_Bridge_UnitN12Out",
773: "Terran_PortCity_Bridge_UnitN8",
772: "Terran_PortCity_Bridge_UnitN8Out",
757: "Terran_PortCity_Bridge_UnitNE10",
756: "Terran_PortCity_Bridge_UnitNE10Out",
765: "Terran_PortCity_Bridge_UnitNE12",
764: "Terran_PortCity_Bridge_UnitNE12Out",
749: "Terran_PortCity_Bridge_UnitNE8",
748: "Terran_PortCity_Bridge_UnitNE8Out",
761: "Terran_PortCity_Bridge_UnitNW10",
760: "Terran_PortCity_Bridge_UnitNW10Out",
769: "Terran_PortCity_Bridge_UnitNW12",
768: "Terran_PortCity_Bridge_UnitNW12Out",
753: "Terran_PortCity_Bridge_UnitNW8",
752: "Terran_PortCity_Bridge_UnitNW8Out",
783: "Terran_PortCity_Bridge_UnitS10",
782: "Terran_PortCity_Bridge_UnitS10Out",
791: "Terran_PortCity_Bridge_UnitS12",
790: "Terran_PortCity_Bridge_UnitS12Out",
775: "Terran_PortCity_Bridge_UnitS8",
774: "Terran_PortCity_Bridge_UnitS8Out",
759: "Terran_PortCity_Bridge_UnitSE10",
758: "Terran_PortCity_Bridge_UnitSE10Out",
767: "Terran_PortCity_Bridge_UnitSE12",
766: "Terran_PortCity_Bridge_UnitSE12Out",
751: "Terran_PortCity_Bridge_UnitSE8",
750: "Terran_PortCity_Bridge_UnitSE8Out",
763: "Terran_PortCity_Bridge_UnitSW10",
762: "Terran_PortCity_Bridge_UnitSW10Out",
771: "Terran_PortCity_Bridge_UnitSW12",
770: "Terran_PortCity_Bridge_UnitSW12Out",
755: "Terran_PortCity_Bridge_UnitSW8",
754: "Terran_PortCity_Bridge_UnitSW8Out",
787: "Terran_PortCity_Bridge_UnitW10",
786: "Terran_PortCity_Bridge_UnitW10Out",
795: "Terran_PortCity_Bridge_UnitW12",
794: "Terran_PortCity_Bridge_UnitW12Out",
779: "Terran_PortCity_Bridge_UnitW8",
778: "Terran_PortCity_Bridge_UnitW8Out",
1981: "Terran_PreviewBunkerUpgraded",
270: "Terran_PunisherGrenadesLMWeapon",
56: "Terran_Raven",
1913: "Terran_RavenRepairDrone",
1917: "Terran_RavenRepairDroneReleaseWeapon",
1916: "Terran_RavenScramblerMissile",
1918: "Terran_RavenShredderMissileWeapon",
6: "Terran_Reactor",
49: "Terran_Reaper",
152: "Terran_ReaperPlaceholder",
20: "Terran_Refinery",
1943: "Terran_RefineryRich",
1939: "Terran_RenegadeLongboltMissileWeapon",
1941: "Terran_RenegadeMissileTurret",
45: "Terran_SCV",
481: "Terran_ScopeTest",
841: "Terran_SeekerMissile",
25: "Terran_SensorTower",
716: "Terran_ShakurasLightBridgeNE10",
715: "Terran_ShakurasLightBridgeNE10Out",
718: "Terran_ShakurasLightBridgeNE12",
717: "Terran_ShakurasLightBridgeNE12Out",
714: "Terran_ShakurasLightBridgeNE8",
713: "Terran_ShakurasLightBridgeNE8Out",
722: "Terran_ShakurasLightBridgeNW10",
721: "Terran_ShakurasLightBridgeNW10Out",
724: "Terran_ShakurasLightBridgeNW12",
723: "Terran_ShakurasLightBridgeNW12Out",
720: "Terran_ShakurasLightBridgeNW8",
719: "Terran_ShakurasLightBridgeNW8Out",
33: "Terran_SiegeTank",
32: "Terran_SiegeTankSieged",
1889: "Terran_SiegeTankSkinPreview",
668: "Terran_SnowRefinery_Terran_ExtendingBridgeNEShort8",
667: "Terran_SnowRefinery_Terran_ExtendingBridgeNEShort8Out",
670: "Terran_SnowRefinery_Terran_ExtendingBridgeNWShort8",
669: "Terran_SnowRefinery_Terran_ExtendingBridgeNWShort8Out",
28: "Terran_Starport",
44: "Terran_StarportFlying",
42: "Terran_StarportReactor",
41: "Terran_StarportTechLab",
19: "Terran_SupplyDepot",
47: "Terran_SupplyDepotLowered",
5: "Terran_TechLab",
52: "Terran_Thor",
807: "Terran_ThorAALance",
269: "Terran_ThorAAWeapon",
691: "Terran_ThorAP",
581: "Terran_TornadoMissileDummyWeapon",
580: "Terran_TornadoMissileWeapon",
595: "Terran_TowerMine",
1940: "Terran_Viking",
34: "Terran_VikingAssault",
35: "Terran_VikingFighter",
271: "Terran_VikingFighterWeapon",
497: "Terran_WarHound",
575: "Terran_WarHoundWeapon",
498: "Terran_WidowMine",
578: "Terran_WidowMineAirWeapon",
500: "Terran_WidowMineBurrowed",
577: "Terran_WidowMineWeapon",
552: "Terran_XelNaga_Caverns_Floating_BridgeH10",
551: "Terran_XelNaga_Caverns_Floating_BridgeH10Out",
556: "Terran_XelNaga_Caverns_Floating_BridgeH12",
555: "Terran_XelNaga_Caverns_Floating_BridgeH12Out",
548: "Terran_XelNaga_Caverns_Floating_BridgeH8",
547: "Terran_XelNaga_Caverns_Floating_BridgeH8Out",
540: "Terran_XelNaga_Caverns_Floating_BridgeNE10",
539: "Terran_XelNaga_Caverns_Floating_BridgeNE10Out",
544: "Terran_XelNaga_Caverns_Floating_BridgeNE12",
543: "Terran_XelNaga_Caverns_Floating_BridgeNE12Out",
536: "Terran_XelNaga_Caverns_Floating_BridgeNE8",
535: "Terran_XelNaga_Caverns_Floating_BridgeNE8Out",
542: "Terran_XelNaga_Caverns_Floating_BridgeNW10",
541: "Terran_XelNaga_Caverns_Floating_BridgeNW10Out",
546: "Terran_XelNaga_Caverns_Floating_BridgeNW12",
545: "Terran_XelNaga_Caverns_Floating_BridgeNW12Out",
538: "Terran_XelNaga_Caverns_Floating_BridgeNW8",
537: "Terran_XelNaga_Caverns_Floating_BridgeNW8Out",
554: "Terran_XelNaga_Caverns_Floating_BridgeV10",
553: "Terran_XelNaga_Caverns_Floating_BridgeV10Out",
558: "Terran_XelNaga_Caverns_Floating_BridgeV12",
557: "Terran_XelNaga_Caverns_Floating_BridgeV12Out",
550: "Terran_XelNaga_Caverns_Floating_BridgeV8",
549: "Terran_XelNaga_Caverns_Floating_BridgeV8Out",
276: "Terran_YamatoWeapon",
278: "Zerg_AcidSalivaWeapon",
293: "Zerg_AcidSpinesWeapon",
9: "Zerg_Baneling",
115: "Zerg_BanelingBurrowed",
8: "Zerg_BanelingCocoon",
96: "Zerg_BanelingNest",
114: "Zerg_BroodLord",
386: "Zerg_BroodLordAWeapon",
290: "Zerg_BroodLordBWeapon",
113: "Zerg_BroodLordCocoon",
385: "Zerg_BroodLordWeapon",
289: "Zerg_Broodling",
143: "Zerg_BroodlingEscort",
822: "Zerg_CausticSprayMissile",
12: "Zerg_Changeling",
15: "Zerg_ChangelingMarine",
14: "Zerg_ChangelingMarineShield",
13: "Zerg_ChangelingZealot",
17: "Zerg_ChangelingZergling",
16: "Zerg_ChangelingZerglingWings",
295: "Zerg_ContaminateWeapon",
897: "Zerg_CorrosiveParasiteWeapon",
263: "Zerg_CorruptionWeapon",
112: "Zerg_Corruptor",
87: "Zerg_CreepTumor",
137: "Zerg_CreepTumorBurrowed",
583: "Zerg_CreepTumorMissile",
138: "Zerg_CreepTumorQueen",
731: "Zerg_DefilerMP",
730: "Zerg_DefilerMPBurrowed",
816: "Zerg_DefilerMPDarkSwarmWeapon",
859: "Zerg_DefilerMPPlagueWeapon",
728: "Zerg_DevourerCocoonMP",
729: "Zerg_DevourerMP",
104: "Zerg_Drone",
116: "Zerg_DroneBurrowed",
103: "Zerg_Egg",
90: "Zerg_EvolutionChamber",
88: "Zerg_Extractor",
1995: "Zerg_ExtractorRich",
576: "Zerg_EyeStalkWeapon",
294: "Zerg_FrenzyWeapon",
313: "Zerg_FungalGrowthMissile",
384: "Zerg_GlaiveWurmBounceWeapon",
282: "Zerg_GlaiveWurmM2Weapon",
283: "Zerg_GlaiveWurmM3Weapon",
281: "Zerg_GlaiveWurmWeapon",
102: "Zerg_GreaterSpire",
726: "Zerg_GuardianCocoonMP",
727: "Zerg_GuardianMP",
814: "Zerg_GuardianMPWeapon",
86: "Zerg_Hatchery",
101: "Zerg_Hive",
107: "Zerg_Hydralisk",
117: "Zerg_HydraliskBurrowed",
91: "Zerg_HydraliskDen",
803: "Zerg_HydraliskImpaleMissile",
94: "Zerg_InfestationPit",
1919: "Zerg_InfestedAcidSpinesWeapon",
150: "Zerg_InfestedTerransEgg",
339: "Zerg_InfestedTerransEggPlacement",
264: "Zerg_InfestedTerransWeapon",
111: "Zerg_Infestor",
127: "Zerg_InfestorBurrowed",
7: "Zerg_InfestorTerran",
120: "Zerg_InfestorTerranBurrowed",
340: "Zerg_InfestorTerransWeapon",
100: "Zerg_Lair",
151: "Zerg_Larva",
292: "Zerg_LarvaReleaseMissile",
489: "Zerg_LocustMP",
584: "Zerg_LocustMPEggAMissileWeapon",
585: "Zerg_LocustMPEggBMissileWeapon",
693: "Zerg_LocustMPFlying",
586: "Zerg_LocustMPWeapon",
504: "Zerg_LurkerDenMP",
502: "Zerg_LurkerMP",
503: "Zerg_LurkerMPBurrowed",
501: "Zerg_LurkerMPEgg",
108: "Zerg_Mutalisk",
314: "Zerg_NeuralParasiteTentacleMissile",
265: "Zerg_NeuralParasiteWeapon",
142: "Zerg_NydusCanal",
491: "Zerg_NydusCanalAttacker",
567: "Zerg_NydusCanalAttackerWeapon",
492: "Zerg_NydusCanalCreeper",
95: "Zerg_NydusNetwork",
106: "Zerg_Overlord",
128: "Zerg_OverlordCocoon",
893: "Zerg_OverlordTransport",
129: "Zerg_Overseer",
1912: "Zerg_OverseerSiegeMode",
288: "Zerg_ParasiteSporeWeapon",
824: "Zerg_ParasiticBombDummy",
823: "Zerg_ParasiticBombMissile",
126: "Zerg_Queen",
125: "Zerg_QueenBurrowed",
860: "Zerg_QueenMP",
817: "Zerg_QueenMPEnsnareMissile",
818: "Zerg_QueenMPSpawnBroodlingsMissile",
688: "Zerg_Ravager",
690: "Zerg_RavagerBurrowed",
687: "Zerg_RavagerCocoon",
802: "Zerg_RavagerCorrosiveBileMissile",
810: "Zerg_RavagerWeaponMissile",
110: "Zerg_Roach",
118: "Zerg_RoachBurrowed",
97: "Zerg_RoachWarren",
858: "Zerg_ScourgeMP",
89: "Zerg_SpawningPool",
98: "Zerg_SpineCrawler",
139: "Zerg_SpineCrawlerUprooted",
279: "Zerg_SpineCrawlerWeapon",
92: "Zerg_Spire",
99: "Zerg_SporeCrawler",
140: "Zerg_SporeCrawlerUprooted",
280: "Zerg_SporeCrawlerWeapon",
493: "Zerg_SwarmHostBurrowedMP",
494: "Zerg_SwarmHostMP",
582: "Zerg_TalonsMissileWeapon",
632: "Zerg_TestZerg",
892: "Zerg_TransportOverlordCocoon",
109: "Zerg_Ultralisk",
131: "Zerg_UltraliskBurrowed",
93: "Zerg_UltraliskCavern",
499: "Zerg_Viper",
568: "Zerg_ViperConsumeStructureWeapon",
383: "Zerg_Weapon",
571: "Zerg_YoinkMissile",
574: "Zerg_YoinkSiegeTankMissile",
572: "Zerg_YoinkVikingAirMissile",
573: "Zerg_YoinkVikingGroundMissile",
105: "Zerg_Zergling",
119: "Zerg_ZerglingBurrowed",
} | enums/unit/strings.go | 0.522202 | 0.412294 | strings.go | starcoder |
package simple
import "honnef.co/go/tools/analysis/lint"
var Docs = map[string]*lint.Documentation{
"S1000": {
Title: `Use plain channel send or receive instead of single-case select`,
Text: `Select statements with a single case can be replaced with a simple
send or receive.
Before:
select {
case x := <-ch:
fmt.Println(x)
}
After:
x := <-ch
fmt.Println(x)`,
Since: "2017.1",
},
"S1001": {
Title: `Replace for loop with call to copy`,
Text: `Use copy() for copying elements from one slice to another.
Before:
for i, x := range src {
dst[i] = x
}
After:
copy(dst, src)`,
Since: "2017.1",
},
"S1002": {
Title: `Omit comparison with boolean constant`,
Text: `Before:
if x == true {}
After:
if x {}`,
Since: "2017.1",
},
"S1003": {
Title: `Replace call to strings.Index with strings.Contains`,
Text: `Before:
if strings.Index(x, y) != -1 {}
After:
if strings.Contains(x, y) {}`,
Since: "2017.1",
},
"S1004": {
Title: `Replace call to bytes.Compare with bytes.Equal`,
Text: `Before:
if bytes.Compare(x, y) == 0 {}
After:
if bytes.Equal(x, y) {}`,
Since: "2017.1",
},
"S1005": {
Title: `Drop unnecessary use of the blank identifier`,
Text: `In many cases, assigning to the blank identifier is unnecessary.
Before:
for _ = range s {}
x, _ = someMap[key]
_ = <-ch
After:
for range s{}
x = someMap[key]
<-ch`,
Since: "2017.1",
},
"S1006": {
Title: `Use for { ... } for infinite loops`,
Text: `For infinite loops, using for { ... } is the most idiomatic choice.`,
Since: "2017.1",
},
"S1007": {
Title: `Simplify regular expression by using raw string literal`,
Text: `Raw string literals use ` + "`" + ` instead of " and do not support
any escape sequences. This means that the backslash (\) can be used
freely, without the need of escaping.
Since regular expressions have their own escape sequences, raw strings
can improve their readability.
Before:
regexp.Compile("\\A(\\w+) profile: total \\d+\\n\\z")
After:
regexp.Compile(` + "`" + `\A(\w+) profile: total \d+\n\z` + "`" + `)`,
Since: "2017.1",
},
"S1008": {
Title: `Simplify returning boolean expression`,
Text: `Before:
if <expr> {
return true
}
return false
After:
return <expr>`,
Since: "2017.1",
},
"S1009": {
Title: `Omit redundant nil check on slices`,
Text: `The len function is defined for all slices, even nil ones, which have
a length of zero. It is not necessary to check if a slice is not nil
before checking that its length is not zero.
Before:
if x != nil && len(x) != 0 {}
After:
if len(x) != 0 {}`,
Since: "2017.1",
},
"S1010": {
Title: `Omit default slice index`,
Text: `When slicing, the second index defaults to the length of the value,
making s[n:len(s)] and s[n:] equivalent.`,
Since: "2017.1",
},
"S1011": {
Title: `Use a single append to concatenate two slices`,
Text: `Before:
for _, e := range y {
x = append(x, e)
}
After:
x = append(x, y...)`,
Since: "2017.1",
},
"S1012": {
Title: `Replace time.Now().Sub(x) with time.Since(x)`,
Text: `The time.Since helper has the same effect as using time.Now().Sub(x)
but is easier to read.
Before:
time.Now().Sub(x)
After:
time.Since(x)`,
Since: "2017.1",
},
"S1016": {
Title: `Use a type conversion instead of manually copying struct fields`,
Text: `Two struct types with identical fields can be converted between each
other. In older versions of Go, the fields had to have identical
struct tags. Since Go 1.8, however, struct tags are ignored during
conversions. It is thus not necessary to manually copy every field
individually.
Before:
var x T1
y := T2{
Field1: x.Field1,
Field2: x.Field2,
}
After:
var x T1
y := T2(x)`,
Since: "2017.1",
},
"S1017": {
Title: `Replace manual trimming with strings.TrimPrefix`,
Text: `Instead of using strings.HasPrefix and manual slicing, use the
strings.TrimPrefix function. If the string doesn't start with the
prefix, the original string will be returned. Using strings.TrimPrefix
reduces complexity, and avoids common bugs, such as off-by-one
mistakes.
Before:
if strings.HasPrefix(str, prefix) {
str = str[len(prefix):]
}
After:
str = strings.TrimPrefix(str, prefix)`,
Since: "2017.1",
},
"S1018": {
Title: `Use copy for sliding elements`,
Text: `copy() permits using the same source and destination slice, even with
overlapping ranges. This makes it ideal for sliding elements in a
slice.
Before:
for i := 0; i < n; i++ {
bs[i] = bs[offset+i]
}
After:
copy(bs[:n], bs[offset:])`,
Since: "2017.1",
},
"S1019": {
Title: `Simplify make call by omitting redundant arguments`,
Text: `The make function has default values for the length and capacity
arguments. For channels and maps, the length defaults to zero.
Additionally, for slices the capacity defaults to the length.`,
Since: "2017.1",
},
"S1020": {
Title: `Omit redundant nil check in type assertion`,
Text: `Before:
if _, ok := i.(T); ok && i != nil {}
After:
if _, ok := i.(T); ok {}`,
Since: "2017.1",
},
"S1021": {
Title: `Merge variable declaration and assignment`,
Text: `Before:
var x uint
x = 1
After:
var x uint = 1`,
Since: "2017.1",
},
"S1023": {
Title: `Omit redundant control flow`,
Text: `Functions that have no return value do not need a return statement as
the final statement of the function.
Switches in Go do not have automatic fallthrough, unlike languages
like C. It is not necessary to have a break statement as the final
statement in a case block.`,
Since: "2017.1",
},
"S1024": {
Title: `Replace x.Sub(time.Now()) with time.Until(x)`,
Text: `The time.Until helper has the same effect as using x.Sub(time.Now())
but is easier to read.
Before:
x.Sub(time.Now())
After:
time.Until(x)`,
Since: "2017.1",
},
"S1025": {
Title: `Don't use fmt.Sprintf("%s", x) unnecessarily`,
Text: `In many instances, there are easier and more efficient ways of getting
a value's string representation. Whenever a value's underlying type is
a string already, or the type has a String method, they should be used
directly.
Given the following shared definitions
type T1 string
type T2 int
func (T2) String() string { return "Hello, world" }
var x string
var y T1
var z T2
we can simplify the following
fmt.Sprintf("%s", x)
fmt.Sprintf("%s", y)
fmt.Sprintf("%s", z)
to
x
string(y)
z.String()`,
Since: "2017.1",
},
"S1028": {
Title: `Simplify error construction with fmt.Errorf`,
Text: `Before:
errors.New(fmt.Sprintf(...))
After:
fmt.Errorf(...)`,
Since: "2017.1",
},
"S1029": {
Title: `Range over the string directly`,
Text: `Ranging over a string will yield byte offsets and runes. If the offset
isn't used, this is functionally equivalent to converting the string
to a slice of runes and ranging over that. Ranging directly over the
string will be more performant, however, as it avoids allocating a new
slice, the size of which depends on the length of the string.
Before:
for _, r := range []rune(s) {}
After:
for _, r := range s {}`,
Since: "2017.1",
},
"S1030": {
Title: `Use bytes.Buffer.String or bytes.Buffer.Bytes`,
Text: `bytes.Buffer has both a String and a Bytes method. It is almost never
necessary to use string(buf.Bytes()) or []byte(buf.String()) – simply
use the other method.
The only exception to this are map lookups. Due to a compiler optimization,
m[string(buf.Bytes())] is more efficient than m[buf.String()].
`,
Since: "2017.1",
},
"S1031": {
Title: `Omit redundant nil check around loop`,
Text: `You can use range on nil slices and maps, the loop will simply never
execute. This makes an additional nil check around the loop
unnecessary.
Before:
if s != nil {
for _, x := range s {
...
}
}
After:
for _, x := range s {
...
}`,
Since: "2017.1",
},
"S1032": {
Title: `Use sort.Ints(x), sort.Float64s(x), and sort.Strings(x)`,
Text: `The sort.Ints, sort.Float64s and sort.Strings functions are easier to
read than sort.Sort(sort.IntSlice(x)), sort.Sort(sort.Float64Slice(x))
and sort.Sort(sort.StringSlice(x)).
Before:
sort.Sort(sort.StringSlice(x))
After:
sort.Strings(x)`,
Since: "2019.1",
},
"S1033": {
Title: `Unnecessary guard around call to delete`,
Text: `Calling delete on a nil map is a no-op.`,
Since: "2019.2",
},
"S1034": {
Title: `Use result of type assertion to simplify cases`,
Since: "2019.2",
},
"S1035": {
Title: `Redundant call to net/http.CanonicalHeaderKey in method call on net/http.Header`,
Text: `The methods on net/http.Header, namely Add, Del, Get and Set, already
canonicalize the given header name.`,
Since: "2020.1",
},
"S1036": {
Title: `Unnecessary guard around map access`,
Text: `When accessing a map key that doesn't exist yet, one
receives a zero value. Often, the zero value is a suitable value, for example when using append or doing integer math.
The following
if _, ok := m["foo"]; ok {
m["foo"] = append(m["foo"], "bar")
} else {
m["foo"] = []string{"bar"}
}
can be simplified to
m["foo"] = append(m["foo"], "bar")
and
if _, ok := m2["k"]; ok {
m2["k"] += 4
} else {
m2["k"] = 4
}
can be simplified to
m["k"] += 4
`,
Since: "2020.1",
},
"S1037": {
Title: `Elaborate way of sleeping`,
Text: `Using a select statement with a single case receiving
from the result of time.After is a very elaborate way of sleeping that
can much simpler be expressed with a simple call to time.Sleep.`,
Since: "2020.1",
},
"S1038": {
Title: "Unnecessarily complex way of printing formatted string",
Text: `Instead of using fmt.Print(fmt.Sprintf(...)), one can use fmt.Printf(...).`,
Since: "2020.1",
},
"S1039": {
Title: "Unnecessary use of fmt.Sprint",
Text: `Calling fmt.Sprint with a single string argument is unnecessary and identical to using the string directly.`,
Since: "2020.1",
},
"S1040": {
Title: "Type assertion to current type",
Text: `The type assertion 'x.(SomeInterface)', when 'x' already has type
'SomeInterface', can only fail if 'x' is nil. Usually, this is
left-over code from when 'x' had a different type and you can safely
delete the type assertion. If you want to check that 'x' is not nil,
consider being explicit and using an actual 'if x == nil' comparison
instead of relying on the type assertion panicking.`,
Since: "Unreleased",
},
} | simple/doc.go | 0.738292 | 0.608885 | doc.go | starcoder |
package levels
import (
"math"
mgl "github.com/go-gl/mathgl/mgl32"
)
// LimitedCamera is a camera implementation with ranged controls for zooming and moving.
type LimitedCamera struct {
viewportWidth, viewportHeight float32
minZoom, maxZoom float32
minPos, maxPos float32
requestedZoomLevel float32
viewOffsetX, viewOffsetY float32
viewMatrix mgl.Mat4
}
// NewLimitedCamera returns a new instance of a LimitedCamera.
func NewLimitedCamera(minZoom, maxZoom float32, minPos, maxPos float32) *LimitedCamera {
cam := &LimitedCamera{
viewportWidth: 1.0,
viewportHeight: 1.0,
minZoom: minZoom,
maxZoom: maxZoom,
minPos: minPos,
maxPos: maxPos,
viewMatrix: mgl.Ident4()}
return cam
}
// SetViewportSize notifies the camera how big the view is.
func (cam *LimitedCamera) SetViewportSize(width, height float32) {
if (cam.viewportWidth != width) || (cam.viewportHeight != height) {
cam.viewportWidth, cam.viewportHeight = width, height
cam.updateViewMatrix()
}
}
// ViewMatrix implements the Viewer interface.
func (cam *LimitedCamera) ViewMatrix() *mgl.Mat4 {
return &cam.viewMatrix
}
// MoveBy adjusts the requested view offset by given delta values in world coordinates.
func (cam *LimitedCamera) MoveBy(dx, dy float32) {
cam.MoveTo(cam.viewOffsetX+dx, cam.viewOffsetY+dy)
}
// MoveTo sets the requested view offset to the given world coordinates.
func (cam *LimitedCamera) MoveTo(worldX, worldY float32) {
cam.viewOffsetX = cam.limitValue(worldX, -cam.maxPos, cam.minPos)
cam.viewOffsetY = cam.limitValue(worldY, -cam.maxPos, cam.minPos)
cam.updateViewMatrix()
}
// ZoomAt adjusts the requested zoom level by given delta, centered around given world position.
// Positive values zoom in.
func (cam *LimitedCamera) ZoomAt(levelDelta float32, x, y float32) {
cam.requestedZoomLevel = cam.limitValue(cam.requestedZoomLevel+levelDelta, cam.minZoom, cam.maxZoom)
focusPoint := mgl.Vec4{x, y, 0.0, 1.0}
oldPixel := cam.viewMatrix.Mul4x1(focusPoint)
cam.updateViewMatrix()
newPixel := cam.viewMatrix.Mul4x1(focusPoint)
scaleFactor := cam.scaleFactor()
cam.MoveBy(-(newPixel[0]-oldPixel[0])/scaleFactor, +(newPixel[1]-oldPixel[1])/scaleFactor)
}
func (cam *LimitedCamera) limitValue(value float32, min, max float32) float32 {
result := value
if result < min {
result = min
}
if result > max {
result = max
}
return result
}
func (cam *LimitedCamera) scaleFactor() float32 {
return float32(math.Pow(2.0, float64(cam.requestedZoomLevel)))
}
func (cam *LimitedCamera) updateViewMatrix() {
scaleFactor := cam.scaleFactor()
cam.viewMatrix = mgl.Ident4().
Mul4(mgl.Translate3D(cam.viewportWidth/2.0, cam.viewportHeight/2.0, 0)).
Mul4(mgl.Scale3D(scaleFactor, -scaleFactor, 1.0)).
Mul4(mgl.Translate3D(cam.viewOffsetX, cam.viewOffsetY, 0))
} | editor/levels/LimitedCamera.go | 0.881092 | 0.481332 | LimitedCamera.go | starcoder |
package filter
import (
"io"
"regexp"
)
// A Filter contains a list of regular expressions matching pathnames which
// should be filtered out: excluded when building or not changed when pushing
// images to a sub.
// A Filter with no lines is an empty filter (nothing is excluded, everything is
// changed when pushing).
// A nil *Filter is a sparse filter: when building nothing is excluded. When
// pushing to a sub, all files are pushed but files on the sub which are not in
// the image are not removed from the sub.
type Filter struct {
FilterLines []string
filterExpressions []*regexp.Regexp
invertMatches bool
}
// A MergeableFilter may be used to combine multiple Filters, eliminating
// duplicate match expressions.
type MergeableFilter struct {
filterLines map[string]struct{}
}
// Load will load a Filter from a file containing newline separated regular
// expressions.
func Load(filename string) (*Filter, error) {
return load(filename)
}
// New will create a Filter from a list of regular expressions, which are
// automatically anchored to the beginning of the string to be matched against.
// If filterLines is of length zero the Filter is an empty Filter.
func New(filterLines []string) (*Filter, error) {
return newFilter(filterLines)
}
// Read will read a Filter from a reader containing newline separated regular
// expressions.
func Read(reader io.Reader) (*Filter, error) {
return read(reader)
}
// Compile will compile the regular expression strings for later use.
func (filter *Filter) Compile() error {
return filter.compile()
}
// Match will return true if pathname matches one of the regular expressions.
// The Compile method will be automatically called if it has not been called
// yet.
func (filter *Filter) Match(pathname string) bool {
return filter.match(pathname)
}
// ReplaceStrings may be used to replace the regular expression strings with
// de-duplicated copies.
func (filter *Filter) ReplaceStrings(replaceFunc func(string) string) {
filter.replaceStrings(replaceFunc)
}
// ExportFilter will return a Filter from previously merged Filters.
func (mf *MergeableFilter) ExportFilter() *Filter {
return mf.exportFilter()
}
// Merge will merge a Filter.
func (mf *MergeableFilter) Merge(filter *Filter) {
mf.merge(filter)
} | lib/filter/api.go | 0.809163 | 0.458712 | api.go | starcoder |
package hbook
import "math"
// dist0D is a 0-dim distribution.
type dist0D struct {
n int64 // number of entries
sumW float64 // sum of weights
sumW2 float64 // sum of squared weights
}
// Rank returns the number of dimensions of the distribution.
func (*dist0D) Rank() int {
return 1
}
// Entries returns the number of entries in the distribution.
func (d *dist0D) Entries() int64 {
return d.n
}
// EffEntries returns the number of weighted entries, such as:
// (\sum w)^2 / \sum w^2
func (d *dist0D) EffEntries() float64 {
if d.sumW2 == 0 {
return 0
}
return d.sumW * d.sumW / d.sumW2
}
// SumW returns the sum of weights of the distribution.
func (d *dist0D) SumW() float64 {
return d.sumW
}
// SumW2 returns the sum of squared weights of the distribution.
func (d *dist0D) SumW2() float64 {
return d.sumW2
}
// errW returns the absolute error on sumW()
func (d *dist0D) errW() float64 {
return math.Sqrt(d.SumW2())
}
// relErrW returns the relative error on sumW()
func (d *dist0D) relErrW() float64 {
// FIXME(sbinet) check for low stats ?
return d.errW() / d.SumW()
}
func (d *dist0D) fill(w float64) {
d.n++
d.sumW += w
d.sumW2 += w * w
}
func (d *dist0D) scaleW(f float64) {
d.sumW *= f
d.sumW2 *= f * f
}
// dist1D is a 1-dim distribution.
type dist1D struct {
dist dist0D // weight moments
sumWX float64 // 1st order weighted x moment
sumWX2 float64 // 2nd order weighted x moment
}
// Rank returns the number of dimensions of the distribution.
func (*dist1D) Rank() int {
return 1
}
// Entries returns the number of entries in the distribution.
func (d *dist1D) Entries() int64 {
return d.dist.Entries()
}
// EffEntries returns the effective number of entries in the distribution.
func (d *dist1D) EffEntries() float64 {
return d.dist.EffEntries()
}
// SumW returns the sum of weights of the distribution.
func (d *dist1D) SumW() float64 {
return d.dist.SumW()
}
// SumW2 returns the sum of squared weights of the distribution.
func (d *dist1D) SumW2() float64 {
return d.dist.SumW2()
}
// SumWX returns the 1st order weighted x moment
func (d *dist1D) SumWX() float64 {
return d.sumWX
}
// SumWX2 returns the 2nd order weighted x moment
func (d *dist1D) SumWX2() float64 {
return d.sumWX2
}
// errW returns the absolute error on sumW()
func (d *dist1D) errW() float64 {
return d.dist.errW()
}
// relErrW returns the relative error on sumW()
func (d *dist1D) relErrW() float64 {
return d.dist.relErrW()
}
// mean returns the weighted mean of the distribution
func (d *dist1D) mean() float64 {
// FIXME(sbinet): check for low stats?
return d.sumWX / d.SumW()
}
// variance returns the weighted variance of the distribution, defined as:
// sig2 = ( \sum(wx^2) * \sum(w) - \sum(wx)^2 ) / ( \sum(w)^2 - \sum(w^2) )
// see: https://en.wikipedia.org/wiki/Weighted_arithmetic_mean
func (d *dist1D) variance() float64 {
// FIXME(sbinet): check for low stats?
sumw := d.SumW()
num := d.sumWX2*sumw - d.sumWX*d.sumWX
den := sumw*sumw - d.SumW2()
v := num / den
return math.Abs(v)
}
// stdDev returns the weighted standard deviation of the distribution
func (d *dist1D) stdDev() float64 {
return math.Sqrt(d.variance())
}
// stdErr returns the weighted standard error of the distribution
func (d *dist1D) stdErr() float64 {
// FIXME(sbinet): check for low stats?
// TODO(sbinet): unbiased should check that Neff>1 and divide by N-1?
return math.Sqrt(d.variance() / d.EffEntries())
}
// rms returns the weighted RMS of the distribution, defined as:
// rms = \sqrt{\sum{w . x^2} / \sum{w}}
func (d *dist1D) rms() float64 {
// FIXME(sbinet): check for low stats?
meansq := d.sumWX2 / d.SumW()
return math.Sqrt(meansq)
}
func (d *dist1D) fill(x, w float64) {
d.dist.fill(w)
d.sumWX += w * x
d.sumWX2 += w * x * x
}
func (d *dist1D) scaleW(f float64) {
d.dist.scaleW(f)
d.sumWX *= f
d.sumWX2 *= f
}
func (d *dist1D) scaleX(f float64) {
d.sumWX *= f
d.sumWX2 *= f * f
}
// dist2D is a 2-dim distribution.
type dist2D struct {
x dist1D // x moments
y dist1D // y moments
sumWXY float64 // 2nd-order cross-term
}
// Rank returns the number of dimensions of the distribution.
func (*dist2D) Rank() int {
return 2
}
// Entries returns the number of entries in the distribution.
func (d *dist2D) Entries() int64 {
return d.x.Entries()
}
// EffEntries returns the effective number of entries in the distribution.
func (d *dist2D) EffEntries() float64 {
return d.x.EffEntries()
}
// SumW returns the sum of weights of the distribution.
func (d *dist2D) SumW() float64 {
return d.x.SumW()
}
// SumW2 returns the sum of squared weights of the distribution.
func (d *dist2D) SumW2() float64 {
return d.x.SumW2()
}
// SumWX returns the 1st order weighted x moment
func (d *dist2D) SumWX() float64 {
return d.x.SumWX()
}
// SumWX2 returns the 2nd order weighted x moment
func (d *dist2D) SumWX2() float64 {
return d.x.SumWX2()
}
// SumWY returns the 1st order weighted y moment
func (d *dist2D) SumWY() float64 {
return d.y.SumWX()
}
// SumWY2 returns the 2nd order weighted y moment
func (d *dist2D) SumWY2() float64 {
return d.y.SumWX2()
}
// errW returns the absolute error on sumW()
func (d *dist2D) errW() float64 {
return d.x.errW()
}
// relErrW returns the relative error on sumW()
func (d *dist2D) relErrW() float64 {
return d.x.relErrW()
}
// xMean returns the weighted mean of the distribution
func (d *dist2D) xMean() float64 {
return d.x.mean()
}
// yMean returns the weighted mean of the distribution
func (d *dist2D) yMean() float64 {
return d.y.mean()
}
// xVariance returns the weighted variance of the distribution
func (d *dist2D) xVariance() float64 {
return d.x.variance()
}
// yVariance returns the weighted variance of the distribution
func (d *dist2D) yVariance() float64 {
return d.y.variance()
}
// xStdDev returns the weighted standard deviation of the distribution
func (d *dist2D) xStdDev() float64 {
return d.x.stdDev()
}
// yStdDev returns the weighted standard deviation of the distribution
func (d *dist2D) yStdDev() float64 {
return d.y.stdDev()
}
// xStdErr returns the weighted standard error of the distribution
func (d *dist2D) xStdErr() float64 {
return d.x.stdErr()
}
// yStdErr returns the weighted standard error of the distribution
func (d *dist2D) yStdErr() float64 {
return d.y.stdErr()
}
// xRMS returns the weighted RMS of the distribution
func (d *dist2D) xRMS() float64 {
return d.x.rms()
}
// yRMS returns the weighted RMS of the distribution
func (d *dist2D) yRMS() float64 {
return d.y.rms()
}
func (d *dist2D) fill(x, y, w float64) {
d.x.fill(x, w)
d.y.fill(y, w)
d.sumWXY += w * x * y
}
func (d *dist2D) scaleW(f float64) {
d.x.scaleW(f)
d.y.scaleW(f)
d.sumWXY *= f
}
func (d *dist2D) scaleX(f float64) {
d.x.scaleX(f)
d.sumWXY *= f
}
func (d *dist2D) scaleY(f float64) {
d.y.scaleX(f)
d.sumWXY *= f
}
func (d *dist2D) scaleXY(fx, fy float64) {
d.scaleX(fx)
d.scaleY(fy)
} | hbook/dist.go | 0.80969 | 0.658795 | dist.go | starcoder |
package config
const (
PartIdentifier = "id"
PartValue = "value"
)
// Sources,
// gitrob: https://github.com/michenriksen/gitrob/blob/master/core/signatures.go
// shhgit: https://github.com/eth0izzle/shhgit/blob/046cf0b704291aafba97d1feff19fe57e5e09152/config.yaml
var SecretMatchers = []map[string]string{
{
"part": PartValue,
"match": ".pem",
"description": "a Potential cryptographic private key",
},
{
"part": PartValue,
"match": ".log",
"description": "a Log file",
"comment": "Log files can contain secret HTTP endpoints, session IDs, API keys and other goodies",
},
{
"part": PartValue,
"match": ".pkcs12",
"description": "a Potential cryptographic key bundle",
},
{
"part": PartValue,
"match": ".p12",
"description": "a Potential cryptographic key bundle",
},
{
"part": PartValue,
"match": ".pfx",
"description": "a Potential cryptographic key bundle",
},
{
"part": PartValue,
"match": ".asc",
"description": "a Potential cryptographic key bundle",
},
{
"part": PartValue,
"match": "otr.private_key",
"description": "a Pidgin OTR private key",
},
{
"part": PartValue,
"match": ".ovpn",
"description": "an OpenVPN client configuration file",
},
{
"part": PartValue,
"match": ".cscfg",
"description": "an Azure service configuration schema file",
},
{
"part": PartValue,
"match": ".rdp",
"description": "a Remote Desktop connection file",
},
{
"part": PartValue,
"match": ".mdf",
"description": "a Microsoft SQL database file",
},
{
"part": PartValue,
"match": ".sdf",
"description": "a Microsoft SQL server compact database file",
},
{
"part": PartValue,
"match": ".sqlite",
"description": "a SQLite database file",
},
{
"part": PartValue,
"match": ".bek",
"description": "a Microsoft BitLocker recovery key file",
},
{
"part": PartValue,
"match": ".tpm",
"description": "a Microsoft BitLocker Trusted Platform Module password file",
},
{
"part": PartValue,
"match": ".fve",
"description": "a Windows BitLocker full volume encrypted data file",
},
{
"part": PartValue,
"match": ".jks",
"description": "a Java keystore file",
},
{
"part": PartValue,
"match": ".psafe3",
"description": "a Password Safe database file",
},
{
"part": PartValue,
"match": "secret_token.rb",
"description": "a Ruby On Rails secret token configuration file",
"comment": "If the Rails secret token is known, it can allow for remote code execution (http://www.exploit-db.com/exploits/27527/)",
},
{
"part": PartValue,
"match": "carrierwave.rb",
"description": "a Carrierwave configuration file",
"comment": "Can contain credentials for cloud storage systems such as Amazon S3 and Google Storage",
},
{
"part": PartValue,
"match": "database.yml",
"description": "a Potential Ruby On Rails database configuration file",
"comment": "Can contain database credentials",
},
{
"part": PartValue,
"match": "omniauth.rb",
"description": "an OmniAuth configuration file",
"comment": "The OmniAuth configuration file can contain client application secrets",
},
{
"part": PartValue,
"match": "settings.py",
"description": "a Django configuration file",
"comment": "Can contain database credentials, cloud storage system credentials, and other secrets",
},
{
"part": PartValue,
"match": ".agilekeychain",
"description": "a 1Password password manager database file",
"comment": "Feed it to Hashcat and see if you're lucky",
},
{
"part": PartValue,
"match": ".keychain",
"description": "a Apple Keychain database file",
},
{
"part": PartValue,
"match": ".pcap",
"description": "a Network traffic capture file",
},
{
"part": PartValue,
"match": ".gnucash",
"description": "a GnuCash database file",
},
{
"part": PartValue,
"match": "jenkins.plugins.publish_over_ssh.BapSshPublisherPlugin.xml",
"description": "a Jenkins publish over SSH plugin file",
},
{
"part": PartValue,
"match": "credentials.xml",
"description": "a Potential Jenkins credentials file",
},
{
"part": PartValue,
"match": ".kwallet",
"description": "a KDE Wallet Manager database file",
},
{
"part": PartValue,
"match": "LocalSettings.php",
"description": "a Potential MediaWiki configuration file",
},
{
"part": PartValue,
"match": ".tblk",
"description": "a Tunnelblick VPN configuration file",
},
{
"part": PartValue,
"match": "a Favorites.plist",
"description": "Sequel Pro MySQL database manager bookmark file",
},
{
"part": PartValue,
"match": "configuration.user.xpl",
"description": "a Little Snitch firewall configuration file",
"comment": "Contains traffic rules for applications",
},
{
"part": PartValue,
"match": ".dayone",
"description": "a Day One journal file",
"comment": "Now it's getting creepy...",
},
{
"part": PartValue,
"match": "journal.txt",
"description": "a Potential jrnl journal file",
"comment": "Now it's getting creepy...",
},
{
"part": PartValue,
"match": "knife.rb",
"description": "Chef Knife configuration file",
"comment": "Can contain references to Chef servers",
},
{
"part": PartValue,
"match": "proftpdpasswd",
"description": "cPanel backup ProFTPd credentials file",
"comment": "Contains usernames and password hashes for FTP accounts",
},
{
"part": PartValue,
"match": "robomongo.json",
"description": "Robomongo MongoDB manager configuration file",
"comment": "Can contain credentials for MongoDB databases",
},
{
"part": PartValue,
"match": "filezilla.xml",
"description": "FileZilla FTP configuration file",
"comment": "Can contain credentials for FTP servers",
},
{
"part": PartValue,
"match": "recentservers.xml",
"description": "FileZilla FTP recent servers file",
"comment": "Can contain credentials for FTP servers",
},
{
"part": PartValue,
"match": "ventrilo_srv.ini",
"description": "Ventrilo server configuration file",
"comment": "Can contain passwords",
},
{
"part": PartValue,
"match": "terraform.tfvars",
"description": "Terraform variable config file",
"comment": "Can contain credentials for terraform providers",
},
{
"part": PartValue,
"match": ".exports",
"description": "Shell configuration file",
"comment": "a Shell configuration files can contain passwords, API keys, hostnames and other goodies",
},
{
"part": PartValue,
"match": ".functions",
"description": "Shell configuration file",
"comment": "a Shell configuration files can contain passwords, API keys, hostnames and other goodies",
},
{
"part": PartValue,
"match": ".extra",
"description": "Shell configuration file",
"comment": "a Shell configuration files can contain passwords, API keys, hostnames and other goodies",
},
{
"part": PartValue,
"match": `^.*_rsa$`,
"description": "a Private SSH key",
},
{
"part": PartValue,
"match": `^.*_dsa$`,
"description": "a Private SSH key",
},
{
"part": PartValue,
"match": `^.*_ed25519$`,
"description": "a Private SSH key",
},
{
"part": PartValue,
"match": `^.*_ecdsa$`,
"description": "a Private SSH key",
},
{
"part": PartValue,
"match": `\.?ssh/config$`,
"description": "a SSH configuration file",
},
{
"part": PartValue,
"match": `^key(pair)?$`,
"description": "a Potential cryptographic private key",
},
{
"part": PartValue,
"match": `^\.?(bash_|zsh_|sh_|z)?history$`,
"description": "a Shell command history file",
},
{
"part": PartValue,
"match": `^\.?mysql_history$`,
"description": "a MySQL client command history file",
},
{
"part": PartValue,
"match": `^\.?psql_history$`,
"description": "a PostgreSQL client command history file",
},
{
"part": PartValue,
"match": `^\.?pgpass$`,
"description": "a PostgreSQL password file",
},
{
"part": PartValue,
"match": `^\.?irb_history$`,
"description": "a Ruby IRB console history file",
},
{
"part": PartValue,
"match": `\.?purple/accounts\.xml$`,
"description": "a Pidgin chat client account configuration file",
},
{
"part": PartValue,
"match": `\.?xchat2?/servlist_?\.conf$`,
"description": "a Hexchat/XChat IRC client server list configuration file",
},
{
"part": PartValue,
"match": `\.?irssi/config$`,
"description": "an Irssi IRC client configuration file",
},
{
"part": PartValue,
"match": `\.?recon-ng/keys\.db$`,
"description": "a Recon-ng web reconnaissance framework API key database",
},
{
"part": PartValue,
"match": `^\.?dbeaver-data-sources.xml$`,
"description": "a DBeaver SQL database manager configuration file",
},
{
"part": PartValue,
"match": `^\.?muttrc$`,
"description": "a Mutt e-mail client configuration file",
},
{
"part": PartValue,
"match": `^\.?s3cfg$`,
"description": "an S3cmd configuration file",
},
{
"part": PartValue,
"match": `\.?aws/credentials$`,
"description": "an AWS CLI credentials file",
},
{
"part": PartValue,
"match": `^sftp-config(\.json)?$`,
"description": "a SFTP connection configuration file",
},
{
"part": PartValue,
"match": `^\.?trc$`,
"description": "a T command-line Twitter client configuration file",
},
{
"part": PartValue,
"match": `^\.?gitrobrc$`,
"description": "a Gitrob configuration file",
},
{
"part": PartValue,
"match": `^\.?(bash|zsh|csh)rc$`,
"description": "a Shell configuration file",
"comment": "Shell configuration files can contain passwords, API keys, hostnames and other goodies",
},
{
"part": PartValue,
"match": `^\.?(bash_|zsh_)?profile$`,
"description": "a Shell profile configuration file",
"comment": "Shell configuration files can contain passwords, API keys, hostnames and other goodies",
},
{
"part": PartValue,
"match": `^\.?(bash_|zsh_)?aliases$`,
"description": "a Shell command alias configuration file",
"comment": "Shell configuration files can contain passwords, API keys, hostnames and other goodies",
},
{
"part": PartValue,
"match": `config(\.inc)?\.php$`,
"description": "a PHP configuration file",
},
{
"part": PartValue,
"match": `^key(store|ring)$`,
"description": "a GNOME Keyring database file",
},
{
"part": PartValue,
"match": `^kdbx?$`,
"description": "a KeePass password manager database file",
"comment": "Feed it to Hashcat and see if you're lucky",
},
{
"part": PartValue,
"match": `^sql(dump)?$`,
"description": "a SQL dump file",
},
{
"part": PartValue,
"match": `^\.?htpasswd$`,
"description": "an Apache htpasswd file",
},
{
"part": PartValue,
"match": `^(\.|_)?netrc$`,
"description": "Configuration file for auto-login process",
"comment": "Can contain username and password",
},
{
"part": PartValue,
"match": `\.?gem/credentials$`,
"description": "Rubygems credentials file",
"comment": "Can contain API key for a rubygems.org account",
},
{
"part": PartValue,
"match": `^\.?tugboat$`,
"description": "a Tugboat DigitalOcean management tool configuration",
},
{
"part": PartValue,
"match": `doctl/config.yaml$`,
"description": "DigitalOcean doctl command-line client configuration file",
"comment": "Contains DigitalOcean API key and other information",
},
{
"part": PartValue,
"match": `^\.?git-credentials$`,
"description": "a git-credential-store helper credentials file",
},
{
"part": PartValue,
"match": `config/hub$`,
"description": "GitHub Hub command-line client configuration file",
"comment": "Can contain GitHub API access token",
},
{
"part": PartValue,
"match": `^\.?gitconfig$`,
"description": "a Git configuration file",
},
{
"part": PartValue,
"match": `\.?chef/(.*)\.pem$`,
"description": "Chef private key",
"comment": "Can be used to authenticate against Chef servers",
},
{
"part": PartValue,
"match": `etc/shadow$`,
"description": "Potential Linux shadow file",
"comment": "Contains hashed passwords for system users",
},
{
"part": PartValue,
"match": `etc/passwd$`,
"description": "Potential Linux passwd file",
"comment": "Contains system user information",
},
{
"part": PartValue,
"match": `^\.?dockercfg$`,
"description": "Docker configuration file",
"comment": "Can contain credentials for public or private Docker registries",
},
{
"part": PartValue,
"match": `^\.?npmrc$`,
"description": "NPM configuration file",
"comment": "Can contain credentials for NPM registries",
},
{
"part": PartValue,
"match": `^\.?env$`,
"description": "an Environment configuration file",
},
{
"part": PartValue,
"match": `(A3T[A-Z0-9]|AKIA|AGPA|AROA|AIPA|ANPA|ANVA|ASIA)[A-Z0-9]{16}`,
"description": "an AWS Access Key ID Value",
},
{
"part": PartValue,
"match": "((\\\"|'|`)?((?i)aws)?_?((?i)access)_?((?i)key)?_?((?i)id)?(\\\"|'|`)?\\\\s{0,50}(:|=>|=)\\\\s{0,50}(\\\"|'|`)?(A3T[A-Z0-9]|AKIA|AGPA|AIDA|AROA|AIPA|ANPA|ANVA|ASIA)[A-Z0-9]{16}(\\\"|'|`)?)",
"description": "an AWS Access Key ID",
},
{
"part": PartValue,
"match": "((\\\"|'|`)?((?i)aws)?_?((?i)account)_?((?i)id)?(\\\"|'|`)?\\\\s{0,50}(:|=>|=)\\\\s{0,50}(\\\"|'|`)?[0-9]{4}-?[0-9]{4}-?[0-9]{4}(\\\"|'|`)?)",
"description": "an AWS Account ID",
},
{
"part": PartValue,
"match": "((\\\"|'|`)?((?i)aws)?_?((?i)secret)_?((?i)access)?_?((?i)key)?_?((?i)id)?(\\\"|'|`)?\\\\s{0,50}(:|=>|=)\\\\s{0,50}(\\\"|'|`)?[A-Za-z0-9/+=]{40}(\\\"|'|`)?)",
"description": "an AWS Secret Access Key",
},
{
"part": PartValue,
"match": "((\\\"|'|`)?((?i)aws)?_?((?i)session)?_?((?i)token)?(\\\"|'|`)?\\\\s{0,50}(:|=>|=)\\\\s{0,50}(\\\"|'|`)?[A-Za-z0-9/+=]{16,}(\\\"|'|`)?)",
"description": "an AWS Session Token",
},
{
"part": PartValue,
"match": "(?i)artifactory.{0,50}(\\\"|'|`)?[a-zA-Z0-9=]{112}(\\\"|'|`)?",
"description": "an Artifactory API Key",
},
{
"part": PartValue,
"match": "(?i)codeclima.{0,50}(\\\"|'|`)?[0-9a-f]{64}(\\\"|'|`)?",
"description": "a CodeClimateAPI Key",
},
{
"part": PartValue,
"match": `EAACEdEose0cBA[0-9A-Za-z]+`,
"description": "a Facebook access token",
},
{
"part": PartValue,
"match": "((\\\"|'|`)?type(\\\"|'|`)?\\\\s{0,50}(:|=>|=)\\\\s{0,50}(\\\"|'|`)?service_account(\\\"|'|`)?,?)",
"description": "a Google (GCM) Service account",
},
{
"part": PartValue,
"match": `(?:r|s)k_[live|test]_[0-9a-zA-Z]{24}`,
"description": "a Stripe API key"},
{
"part": PartValue,
"match": `[0-9]+-[0-9A-Za-z_]{32}\.apps\.googleusercontent\.com`,
"description": "a Google OAuth Key"},
{
"part": PartValue,
"match": `AIza[0-9A-Za-z\\-_]{35}`,
"description": "a Google Cloud API Key",
},
{
"part": PartValue,
"match": `ya29\\.[0-9A-Za-z\\-_]+`,
"description": "a Google OAuth Access Token",
},
{
"part": PartValue,
"match": `sk_[live|test]_[0-9a-z]{32}`,
"description": "a Picatic API key",
},
{
"part": PartValue,
"match": `sq0atp-[0-9A-Za-z\-_]{22}`,
"description": "a Square Access Token",
},
{
"part": PartValue,
"match": `sq0csp-[0-9A-Za-z\-_]{43}`,
"description": "a Square OAuth Secret"},
{
"part": PartValue,
"match": `access_token\$production\$[0-9a-z]{16}\$[0-9a-f]{32}`,
"description": "a PayPal/Braintree Access Token",
},
{
"part": PartValue,
"match": `amzn\.mws\.[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}`,
"description": "an Amazon MWS Auth Token",
},
{
"part": PartValue,
"match": `SK[0-9a-fA-F]{32}`,
"description": "a Twilio API Key",
},
{
"part": PartValue,
"match": `SG\.[0-9A-Za-z\-_]{22}\.[0-9A-Za-z\-_]{43}`,
"description": "a SendGrid API Key",
},
{
"part": PartValue,
"match": `key-[0-9a-zA-Z]{32}`,
"description": "a MailGun API Key",
},
{
"part": PartValue,
"match": `[0-9a-f]{32}-us[0-9]{12}`,
"description": "a MailChimp API Key",
},
{
"part": PartValue,
"match": "sshpass -p.*['|\\\"]",
"description": "an SSH Password",
},
{
"part": PartValue,
"match": `(https\\://outlook\\.office.com/webhook/[0-9a-f-]{36}\\@)`,
"description": "an Outlook team",
},
{
"part": PartValue,
"match": "(?i)sauce.{0,50}(\\\"|'|`)?[0-9a-f-]{36}(\\\"|'|`)?",
"description": "a Sauce Token",
},
{
"part": PartValue,
"match": `(xox[pboa]-[0-9]{12}-[0-9]{12}-[0-9]{12}-[a-z0-9]{32})`,
"description": "a Slack Token",
},
{
"part": PartValue,
"match": `https://hooks.slack.com/services/T[a-zA-Z0-9_]{8}/B[a-zA-Z0-9_]{8}/[a-zA-Z0-9_]{24}`,
"description": "a Slack Webhook",
},
{
"part": PartValue,
"match": "(?i)sonar.{0,50}(\\\"|'|`)?[0-9a-f]{40}(\\\"|'|`)?",
"description": "a SonarQube Docs API Key",
},
{
"part": PartValue,
"match": "(?i)hockey.{0,50}(\\\"|'|`)?[0-9a-f]{32}(\\\"|'|`)?",
"description": "a HockeyApp Key",
},
{
"part": PartValue,
"match": `([\w+]{1,24})(://)([^$<]{1})([^\s";]{1,}):([^$<]{1})([^\s";/]{1,})@[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,24}([^\s]+)`,
"description": "has Username and password in URI",
},
{
"part": PartValue,
"match": `oy2[a-z0-9]{43}`,
"description": "a NuGet API Key",
},
{
"part": PartValue,
"match": `hawk\.[0-9A-Za-z\-_]{20}\.[0-9A-Za-z\-_]{20}`,
"description": "a StackHawk API Key",
},
{
"part": PartValue,
"match": `-----BEGIN (EC|RSA|DSA|OPENSSH|PGP) PRIVATE KEY`,
"description": "Contains a private key",
},
{
"part": PartValue,
"match": `define(.{0,20})?(DB_CHARSET|NONCE_SALT|LOGGED_IN_SALT|AUTH_SALT|NONCE_KEY|DB_HOST|DB_PASSWORD|AUTH_KEY|SECURE_AUTH_KEY|LOGGED_IN_KEY|DB_NAME|DB_USER)(.{0,20})?[', '|"].{10,120}[', '|"]`,
"description": "WP-Config",
},
{
"part": PartValue,
"match": `(?i)(aws_access_key_id|aws_secret_access_key)(.{0,20})?=.[0-9a-zA-Z\/+]{20,40}`,
"description": "an AWS cred file info",
},
{
"part": PartValue,
"match": `(?i)(facebook|fb)(.{0,20})?(?-i)[', '\"][0-9a-f]{32}[', '\"]`,
"description": "a Facebook Secret Key",
},
{
"part": PartValue,
"match": `(?i)(facebook|fb)(.{0,20})?[', '\"][0-9]{13,17}[', '\"]`,
"description": "a Facebook Client ID",
},
{
"part": PartValue,
"match": `(?i)twitter(.{0,20})?[', '\"][0-9a-z]{35,44}[', '\"]`,
"description": "a Twitter Secret Key",
},
{
"part": PartValue,
"match": `(?i)twitter(.{0,20})?[', '\"][0-9a-z]{18,25}[', '\"]`,
"description": "a Twitter Client ID",
},
{
"part": PartValue,
"match": `(?i)github(.{0,20})?(?-i)[', '\"][0-9a-zA-Z]{35,40}[', '\"]`,
"description": "a Github Key",
},
{
"part": PartValue,
"match": `(?i)heroku(.{0,20})?[', '"][0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}[', '"]`,
"description": "a Heroku API key",
},
{
"part": PartValue,
"match": `(?i)linkedin(.{0,20})?(?-i)[', '\"][0-9a-z]{12}[', '\"]`,
"description": "a Linkedin Client ID",
},
{
"part": PartValue,
"match": `(?i)linkedin(.{0,20})?[', '\"][0-9a-z]{16}[', '\"]`,
"description": "a LinkedIn Secret Key",
},
{
"part": PartIdentifier,
"match": `(?i)credential`,
"description": "Contains word: credential",
},
{
"part": PartIdentifier,
"match": `(?i)user`,
"description": "Contains word: user",
},
{
"part": PartIdentifier,
"match": `(?i).*password.*`,
"description": "Contains word: password",
},
{
"part": PartIdentifier,
"match": `(?i)host`,
"description": "Contains word: host",
},
{
"part": PartIdentifier,
"match": `(?i)(access)?.*_?.*(key)?.*_?.*id`,
"description": "Contains words: (access or key) and id",
},
{
"part": PartIdentifier,
"match": `(?i)(secret)?.*_?.*(access)?.*_?.*key`,
"description": "Contains words: (secret or access) and key",
},
} | pkg/kev/config/secrets.go | 0.68763 | 0.452113 | secrets.go | starcoder |
package mathx
import "math"
// Min returns the minimum value in the list of values [a, rest...]
// If rest is empty, the result is a.
func Min(a float64, rest ...float64) float64 {
var min = a
for _, v := range rest {
switch {
case math.IsNaN(v), math.IsInf(v, -1):
return v
default:
min = math.Min(min, v)
}
}
return min
}
// MinIndex returns the minimum value in the list of values.
// Returns index of first -Inf value.
// Returns -1 if the list is empty or contains a NaN value.
// If there several entries of the minimum in the list,
// then returns the index of the last occurrence.
func MinIndex(ff []float64) int {
var index = -1
if len(ff) == 0 {
return index
}
var min = ff[0]
for i, v := range ff[1:] {
switch {
case math.IsInf(v, -1):
return i
case math.IsNaN(v):
return -1
case v == math.Min(v, min):
index = i
min = v
}
}
return index
}
// Max returns the maximum value in the list of values [a, rest...]
// If rest is empty, the result is a.
func Max(a float64, rest ...float64) float64 {
var max = a
for _, v := range rest {
switch {
case math.IsNaN(v), math.IsInf(v, 1):
return v
default:
max = math.Max(max, v)
}
}
return max
}
// MaxIndex returns the maximum value in the list of values.
// Returns index of first +Inf value.
// Returns -1 if the list is empty or contains a NaN value.
// If there several entries of the maximum in the list,
// then returns the index of the last occurrence.
func MaxIndex(ff []float64) int {
var index = -1
if len(ff) == 0 {
return index
}
var max = ff[0]
for i, v := range ff[1:] {
switch {
case math.IsInf(v, 1), math.IsNaN(v):
return -1
case v == math.Max(v, max):
index = i
max = v
}
}
return index
}
// MinInt returns the smallest integer from the list of [a, rest...].
func MinInt(a int, rest ...int) int {
var min = a
for _, v := range rest {
min = minInt(min, v)
}
return min
}
func minInt(a, b int) int {
if a < b {
return a
}
return b
}
// MaxInt returns the smallest integer from the list of [a, rest...].
func MaxInt(a int, rest ...int) int {
var max = a
for _, v := range rest {
max = maxInt(max, v)
}
return max
}
func maxInt(a, b int) int {
if a > b {
return a
}
return b
} | cmp.go | 0.802362 | 0.568536 | cmp.go | starcoder |
package main
import (
"fmt"
"math"
"sort"
"time"
)
// Stat represents one statistical measurement.
type Stat struct {
Label []byte
Value float64
}
// Init safely initializes a stat while minimizing heap allocations.
func (s *Stat) Init(label []byte, value float64) {
s.Label = s.Label[:0] // clear
s.Label = append(s.Label, label...)
s.Value = value
}
// StatGroup collects simple streaming statistics.
type StatGroup struct {
Min float64
Max float64
Mean float64
Sum float64
Count int64
}
// Push updates a StatGroup with a new value.
func (s *StatGroup) Push(n float64) {
if s.Count == 0 {
s.Min = n
s.Max = n
s.Mean = n
s.Count = 1
s.Sum = n
return
}
if n < s.Min {
s.Min = n
}
if n > s.Max {
s.Max = n
}
s.Sum += n
// constant-space mean update:
sum := s.Mean*float64(s.Count) + n
s.Mean = sum / float64(s.Count+1)
s.Count++
}
// String makes a simple description of a StatGroup.
func (s *StatGroup) String() string {
return fmt.Sprintf("min: %f, max: %f, mean: %f, count: %d, sum: %f", s.Min, s.Max, s.Mean, s.Count, s.Sum)
}
type timedStat struct {
timestamp time.Time
value float64
}
type HistoryItem struct {
value float64
item int
}
type TimedStatGroup struct {
maxDuraton time.Duration
stats []timedStat
lastAvg float64
lastMedian float64
lastRate float64
trendAvg *TrendStat
statHistory []*HistoryItem
}
func NewTimedStatGroup(maxDuration time.Duration, maxTrendSamples int) *TimedStatGroup {
return &TimedStatGroup{maxDuraton: maxDuration, stats: make([]timedStat, 0, 100000), trendAvg: NewTrendStat(maxTrendSamples, true), statHistory: make([]*HistoryItem, 0, 512)}
}
func (m *TimedStatGroup) Push(timestamp time.Time, value float64) {
m.stats = append(m.stats, timedStat{timestamp: timestamp, value: value})
}
func (m *TimedStatGroup) Avg() float64 {
return m.lastAvg
}
func (m *TimedStatGroup) Rate() float64 {
return m.lastRate
}
func (m *TimedStatGroup) Median() float64 {
return m.lastMedian
}
func (m *TimedStatGroup) UpdateAvg(now time.Time, workers int) (float64, float64) {
newStats := make([]timedStat, 0, len(m.stats))
last := now.Add(-m.maxDuraton)
sum := float64(0)
c := 0
first := now
for _, ts := range m.stats {
if ts.timestamp.After(last) {
sum += ts.value
c++
newStats = append(newStats, ts)
if ts.timestamp.Before(first) {
first = ts.timestamp
}
}
}
m.stats = nil
m.stats = newStats
l := len(newStats)
if l == 0 {
m.lastMedian = math.NaN()
} else {
sort.Slice(newStats, func(i, j int) bool {
return newStats[i].value < newStats[j].value
})
m.lastMedian = newStats[l/2].value
}
m.lastAvg = sum / float64(c)
m.lastRate = sum / now.Sub(first).Seconds()
m.statHistory = append(m.statHistory, &HistoryItem{m.lastRate, workers})
m.trendAvg.Add(m.lastAvg)
return m.lastAvg, m.lastMedian
}
type TrendStat struct {
x, y []float64
size int
slope float64
intercept float64
skipFirst bool
}
func (ls *TrendStat) Add(y float64) {
c := len(ls.y)
if c == 0 {
if ls.skipFirst {
ls.skipFirst = false
return
}
}
y = y / 1000 // normalize to seconds
if c < ls.size {
ls.y = append(ls.y, y)
c++
if c < 5 { // at least 5 samples required for regression
return
}
} else { // shift left using copy and insert at last position - hopefully no reallocation
y1 := ls.y[1:]
copy(ls.y, y1)
ls.y[ls.size-1] = y
}
if c > ls.size {
panic("Bug in implementation")
}
//var r stats.Regression
var r SimpleRegression
r.hasIntercept = false
for i := 0; i < c; i++ {
r.Update(ls.x[i], ls.y[i]-ls.y[0])
}
ls.slope = r.Slope()
ls.intercept = (r.Intercept() + ls.y[0]) * 1000
}
func NewTrendStat(size int, skipFirst bool) *TrendStat {
fmt.Printf("Trend statistics using %d samples\n", size)
instance := TrendStat{
size: size,
slope: 0,
skipFirst: skipFirst,
}
instance.x = make([]float64, size, size)
instance.y = make([]float64, 0, size)
for i := 0; i < size; i++ {
instance.x[i] = float64(i) // X is constant array { 0, 1, 2 ... size }
}
return &instance
}
type SimpleRegression struct {
sumX float64
sumXX float64
sumY float64
sumYY float64
sumXY float64
n float64
xbar float64
ybar float64
hasIntercept bool
}
func (sr *SimpleRegression) Update(x, y float64) {
if sr.n == 0 {
sr.xbar = x
sr.ybar = y
} else {
if sr.hasIntercept {
fact1 := 1.0 + sr.n
fact2 := sr.n / (1.0 + sr.n)
dx := x - sr.xbar
dy := y - sr.ybar
sr.sumXX += dx * dx * fact2
sr.sumYY += dy * dy * fact2
sr.sumXY += dx * dy * fact2
sr.xbar += dx / fact1
sr.ybar += dy / fact1
}
}
if !sr.hasIntercept {
sr.sumXX += x * x
sr.sumYY += y * y
sr.sumXY += x * y
}
sr.sumX += x
sr.sumY += y
sr.n++
}
func (sr *SimpleRegression) Intercept() float64 {
if sr.hasIntercept {
return (sr.sumY - sr.Slope()*sr.sumX) / sr.n
} else {
return 0
}
}
func (sr *SimpleRegression) Slope() float64 {
if sr.n < 2 {
return math.NaN()
}
return sr.sumXY / sr.sumXX
} | cmd/bulk_load_influx/stats.go | 0.682362 | 0.523603 | stats.go | starcoder |
package framework
import (
"github.com/onsi/gomega"
)
// ExpectEqual expects the specified two are the same, otherwise an exception raises
func ExpectEqual(actual interface{}, extra interface{}, explain ...interface{}) {
gomega.ExpectWithOffset(1, actual).To(gomega.Equal(extra), explain...)
}
// ExpectNotEqual expects the specified two are not the same, otherwise an exception raises
func ExpectNotEqual(actual interface{}, extra interface{}, explain ...interface{}) {
gomega.ExpectWithOffset(1, actual).NotTo(gomega.Equal(extra), explain...)
}
// ExpectError expects an error happens, otherwise an exception raises
func ExpectError(err error, explain ...interface{}) {
gomega.ExpectWithOffset(1, err).To(gomega.HaveOccurred(), explain...)
}
// ExpectNoError checks if "err" is set, and if so, fails assertion while logging the error.
func ExpectNoError(err error, explain ...interface{}) {
ExpectNoErrorWithOffset(1, err, explain...)
}
// ExpectNoErrorWithOffset checks if "err" is set, and if so, fails assertion while logging the error at "offset" levels above its caller
// (for example, for call chain f -> g -> ExpectNoErrorWithOffset(1, ...) error would be logged for "f").
func ExpectNoErrorWithOffset(offset int, err error, explain ...interface{}) {
gomega.ExpectWithOffset(1+offset, err).NotTo(gomega.HaveOccurred(), explain...)
}
// ExpectConsistOf expects actual contains precisely the extra elements. The ordering of the elements does not matter.
func ExpectConsistOf(actual interface{}, extra interface{}, explain ...interface{}) {
gomega.ExpectWithOffset(1, actual).To(gomega.ConsistOf(extra), explain...)
}
// ExpectHaveKey expects the actual map has the key in the keyset
func ExpectHaveKey(actual interface{}, key interface{}, explain ...interface{}) {
gomega.ExpectWithOffset(1, actual).To(gomega.HaveKey(key), explain...)
}
// ExpectEmpty expects actual is empty
func ExpectEmpty(actual interface{}, explain ...interface{}) {
gomega.ExpectWithOffset(1, actual).To(gomega.BeEmpty(), explain...)
} | test/e2e/framework/expect.go | 0.727201 | 0.612455 | expect.go | starcoder |
package game
import (
"math"
"github.com/go-gl/mathgl/mgl32"
"github.com/samuelyuan/openbiohazard2/fileio"
"github.com/samuelyuan/openbiohazard2/world"
)
const (
PLAYER_FORWARD_SPEED = 4000
PLAYER_BACKWARD_SPEED = 1000
)
type Player struct {
Position mgl32.Vec3
RotationAngle float32
PoseNumber int
}
// Position is in world space
// Rotation angle is in degrees
func NewPlayer(initialPosition mgl32.Vec3, initialRotationAngle float32) *Player {
return &Player{
Position: initialPosition,
RotationAngle: initialRotationAngle,
PoseNumber: -1,
}
}
func (p *Player) GetModelMatrix() mgl32.Mat4 {
modelMatrix := mgl32.Ident4()
modelMatrix = modelMatrix.Mul4(mgl32.Translate3D(p.Position.X(), p.Position.Y(), p.Position.Z()))
modelMatrix = modelMatrix.Mul4(mgl32.HomogRotate3DY(mgl32.DegToRad(float32(p.RotationAngle))))
return modelMatrix
}
func (player *Player) HandlePlayerInputForward(collisionEntities []fileio.CollisionEntity, timeElapsedSeconds float64) {
predictPosition := player.PredictPositionForward(timeElapsedSeconds)
collidingEntity := world.CheckCollision(predictPosition, collisionEntities)
if collidingEntity == nil {
player.Position = predictPosition
player.PoseNumber = 0
} else {
if world.CheckRamp(collidingEntity) {
player.Position = player.PredictPositionForwardSlope(collidingEntity, timeElapsedSeconds)
player.PoseNumber = 0
} else if collidingEntity.Shape == 9 || collidingEntity.Shape == 10 {
player.Position = player.PredictPositionClimbBox()
} else {
player.PoseNumber = -1
}
}
}
func (player *Player) HandlePlayerInputBackward(collisionEntities []fileio.CollisionEntity, timeElapsedSeconds float64) {
predictPosition := player.PredictPositionBackward(timeElapsedSeconds)
collidingEntity := world.CheckCollision(predictPosition, collisionEntities)
if collidingEntity == nil {
player.Position = predictPosition
player.PoseNumber = 1
} else {
if world.CheckRamp(collidingEntity) {
player.Position = player.PredictPositionBackwardSlope(collidingEntity, timeElapsedSeconds)
player.PoseNumber = 1
} else {
player.PoseNumber = -1
}
}
}
func (player *Player) PredictPositionForward(timeElapsedSeconds float64) mgl32.Vec3 {
modelMatrix := mgl32.Ident4()
modelMatrix = modelMatrix.Mul4(mgl32.HomogRotate3DY(mgl32.DegToRad(player.RotationAngle)))
movementDelta := modelMatrix.Mul4x1(mgl32.Vec4{PLAYER_FORWARD_SPEED * float32(timeElapsedSeconds), 0.0, 0.0, 0.0})
return player.Position.Add(mgl32.Vec3{movementDelta.X(), movementDelta.Y(), movementDelta.Z()})
}
func (player *Player) PredictPositionBackward(timeElapsedSeconds float64) mgl32.Vec3 {
modelMatrix := mgl32.Ident4()
modelMatrix = modelMatrix.Mul4(mgl32.HomogRotate3DY(mgl32.DegToRad(player.RotationAngle)))
movementDelta := modelMatrix.Mul4x1(mgl32.Vec4{-1 * PLAYER_BACKWARD_SPEED * float32(timeElapsedSeconds), 0.0, 0.0, 0.0})
return player.Position.Add(mgl32.Vec3{movementDelta.X(), movementDelta.Y(), movementDelta.Z()})
}
func (player *Player) RotatePlayerLeft(timeElapsedSeconds float64) {
player.RotationAngle -= 100 * float32(timeElapsedSeconds)
if player.RotationAngle < 0 {
player.RotationAngle += 360
}
}
func (player *Player) RotatePlayerRight(timeElapsedSeconds float64) {
player.RotationAngle += 100 * float32(timeElapsedSeconds)
if player.RotationAngle > 360 {
player.RotationAngle -= 360
}
}
func (player *Player) PredictPositionForwardSlope(
slopedEntity *fileio.CollisionEntity,
timeElapsedSeconds float64,
) mgl32.Vec3 {
predictPositionFlat := player.PredictPositionForward(timeElapsedSeconds)
return player.PredictPositionSlope(predictPositionFlat, slopedEntity)
}
func (player *Player) PredictPositionBackwardSlope(
slopedEntity *fileio.CollisionEntity,
timeElapsedSeconds float64,
) mgl32.Vec3 {
predictPositionFlat := player.PredictPositionBackward(timeElapsedSeconds)
return player.PredictPositionSlope(predictPositionFlat, slopedEntity)
}
// Player walks up or down the stairs or ramp
func (player *Player) PredictPositionSlope(predictPositionFlat mgl32.Vec3, slopedEntity *fileio.CollisionEntity) mgl32.Vec3 {
distanceFromRampBottom := 0.0
// Check slope type orientation
if slopedEntity.SlopeType == 0 || slopedEntity.SlopeType == 1 {
// ramp bottom is on the x-axis
distanceFromRampBottom = math.Abs(float64(predictPositionFlat.X()-slopedEntity.RampBottom)) / float64(slopedEntity.Width)
} else if slopedEntity.SlopeType == 2 || slopedEntity.SlopeType == 3 {
// ramp bottom is on the z-axis
distanceFromRampBottom = math.Abs(float64(predictPositionFlat.Z()-slopedEntity.RampBottom)) / float64(slopedEntity.Density)
}
predictPositionY := float64(slopedEntity.SlopeHeight) * distanceFromRampBottom
return mgl32.Vec3{predictPositionFlat.X(), float32(predictPositionY), predictPositionFlat.Z()}
}
func (player *Player) PredictPositionClimbBox() mgl32.Vec3 {
playerFloorNum := int(math.Round(float64(player.Position.Y()) / fileio.FLOOR_HEIGHT_UNIT))
if playerFloorNum == 0 {
// player is on the ground
// climb up
return mgl32.Vec3{player.Position.X(), fileio.FLOOR_HEIGHT_UNIT, player.Position.Z()}
} else if playerFloorNum == 1 {
// player is on the box
// climb down
return mgl32.Vec3{player.Position.X(), 0.0, player.Position.Z()}
}
return player.Position
}
func (gameDef *GameDef) HandlePlayerActionButton(collisionEntities []fileio.CollisionEntity) {
} | game/player.go | 0.772273 | 0.469642 | player.go | starcoder |
package storetest
import (
"sort"
"testing"
"github.com/stretchr/testify/require"
"github.com/zacmm/zacmm-server/model"
"github.com/zacmm/zacmm-server/store"
"github.com/stretchr/testify/assert"
)
func TestPluginStore(t *testing.T, ss store.Store, s SqlSupplier) {
t.Run("SaveOrUpdate", func(t *testing.T) { testPluginSaveOrUpdate(t, ss, s) })
t.Run("CompareAndSet", func(t *testing.T) { testPluginCompareAndSet(t, ss, s) })
t.Run("CompareAndDelete", func(t *testing.T) { testPluginCompareAndDelete(t, ss, s) })
t.Run("SetWithOptions", func(t *testing.T) { testPluginSetWithOptions(t, ss, s) })
t.Run("Get", func(t *testing.T) { testPluginGet(t, ss) })
t.Run("Delete", func(t *testing.T) { testPluginDelete(t, ss) })
t.Run("DeleteAllForPlugin", func(t *testing.T) { testPluginDeleteAllForPlugin(t, ss) })
t.Run("DeleteAllExpired", func(t *testing.T) { testPluginDeleteAllExpired(t, ss) })
t.Run("List", func(t *testing.T) { testPluginList(t, ss) })
}
func setupKVs(t *testing.T, ss store.Store) (string, func()) {
pluginId := model.NewId()
otherPluginId := model.NewId()
// otherKV is another key value for the current plugin, and used to verify other keys
// aren't modified unintentionally.
otherKV := &model.PluginKeyValue{
PluginId: pluginId,
Key: model.NewId(),
Value: []byte(model.NewId()),
ExpireAt: 0,
}
_, err := ss.Plugin().SaveOrUpdate(otherKV)
require.Nil(t, err)
// otherPluginKV is a key value for another plugin, and used to verify other plugins' keys
// aren't modified unintentionally.
otherPluginKV := &model.PluginKeyValue{
PluginId: otherPluginId,
Key: model.NewId(),
Value: []byte(model.NewId()),
ExpireAt: 0,
}
_, err = ss.Plugin().SaveOrUpdate(otherPluginKV)
require.Nil(t, err)
return pluginId, func() {
actualOtherKV, err := ss.Plugin().Get(otherKV.PluginId, otherKV.Key)
require.Nil(t, err, "failed to find other key value for same plugin")
assert.Equal(t, otherKV, actualOtherKV)
actualOtherPluginKV, err := ss.Plugin().Get(otherPluginKV.PluginId, otherPluginKV.Key)
require.Nil(t, err, "failed to find other key value from different plugin")
assert.Equal(t, otherPluginKV, actualOtherPluginKV)
}
}
func doTestPluginSaveOrUpdate(t *testing.T, ss store.Store, s SqlSupplier, doer func(kv *model.PluginKeyValue) (*model.PluginKeyValue, error)) {
t.Run("invalid kv", func(t *testing.T) {
_, tearDown := setupKVs(t, ss)
defer tearDown()
kv := &model.PluginKeyValue{
PluginId: "",
Key: model.NewId(),
Value: []byte(model.NewId()),
ExpireAt: 0,
}
kv, err := doer(kv)
require.NotNil(t, err)
appErr, ok := err.(*model.AppError)
require.True(t, ok)
require.Equal(t, "model.plugin_key_value.is_valid.plugin_id.app_error", appErr.Id)
assert.Nil(t, kv)
})
t.Run("new key", func(t *testing.T) {
pluginId, tearDown := setupKVs(t, ss)
defer tearDown()
key := model.NewId()
value := model.NewId()
expireAt := int64(0)
kv := &model.PluginKeyValue{
PluginId: pluginId,
Key: key,
Value: []byte(value),
ExpireAt: expireAt,
}
retKV, err := doer(kv)
require.Nil(t, err)
assert.Equal(t, kv, retKV)
// SaveOrUpdate returns the kv passed in, so test each field individually for
// completeness. It should probably be changed to not bother doing that.
assert.Equal(t, pluginId, kv.PluginId)
assert.Equal(t, key, kv.Key)
assert.Equal(t, []byte(value), kv.Value)
assert.Equal(t, expireAt, kv.ExpireAt)
actualKV, nErr := ss.Plugin().Get(pluginId, key)
require.Nil(t, nErr)
assert.Equal(t, kv, actualKV)
})
t.Run("nil value for new key", func(t *testing.T) {
pluginId, tearDown := setupKVs(t, ss)
defer tearDown()
key := model.NewId()
var value []byte
expireAt := int64(0)
kv := &model.PluginKeyValue{
PluginId: pluginId,
Key: key,
Value: value,
ExpireAt: expireAt,
}
retKV, err := doer(kv)
require.Nil(t, err)
assert.Equal(t, kv, retKV)
// SaveOrUpdate returns the kv passed in, so test each field individually for
// completeness. It should probably be changed to not bother doing that.
assert.Equal(t, pluginId, kv.PluginId)
assert.Equal(t, key, kv.Key)
assert.Nil(t, kv.Value)
assert.Equal(t, expireAt, kv.ExpireAt)
actualKV, nErr := ss.Plugin().Get(pluginId, key)
_, ok := nErr.(*store.ErrNotFound)
require.NotNil(t, nErr)
assert.True(t, ok)
assert.Nil(t, actualKV)
})
t.Run("existing key", func(t *testing.T) {
pluginId, tearDown := setupKVs(t, ss)
defer tearDown()
key := model.NewId()
value := model.NewId()
expireAt := int64(0)
kv := &model.PluginKeyValue{
PluginId: pluginId,
Key: key,
Value: []byte(value),
ExpireAt: expireAt,
}
_, err := doer(kv)
require.Nil(t, err)
newValue := model.NewId()
kv.Value = []byte(newValue)
retKV, err := doer(kv)
require.Nil(t, err)
assert.Equal(t, kv, retKV)
// SaveOrUpdate returns the kv passed in, so test each field individually for
// completeness. It should probably be changed to not bother doing that.
assert.Equal(t, pluginId, kv.PluginId)
assert.Equal(t, key, kv.Key)
assert.Equal(t, []byte(newValue), kv.Value)
assert.Equal(t, expireAt, kv.ExpireAt)
actualKV, nErr := ss.Plugin().Get(pluginId, key)
require.Nil(t, nErr)
assert.Equal(t, kv, actualKV)
})
t.Run("nil value for existing key", func(t *testing.T) {
pluginId, tearDown := setupKVs(t, ss)
defer tearDown()
key := model.NewId()
value := model.NewId()
expireAt := int64(0)
kv := &model.PluginKeyValue{
PluginId: pluginId,
Key: key,
Value: []byte(value),
ExpireAt: expireAt,
}
_, err := doer(kv)
require.Nil(t, err)
kv.Value = nil
retKV, err := doer(kv)
require.Nil(t, err)
assert.Equal(t, kv, retKV)
// SaveOrUpdate returns the kv passed in, so test each field individually for
// completeness. It should probably be changed to not bother doing that.
assert.Equal(t, pluginId, kv.PluginId)
assert.Equal(t, key, kv.Key)
assert.Nil(t, kv.Value)
assert.Equal(t, expireAt, kv.ExpireAt)
actualKV, nErr := ss.Plugin().Get(pluginId, key)
_, ok := nErr.(*store.ErrNotFound)
require.NotNil(t, nErr)
assert.True(t, ok)
assert.Nil(t, actualKV)
})
}
func testPluginSaveOrUpdate(t *testing.T, ss store.Store, s SqlSupplier) {
doTestPluginSaveOrUpdate(t, ss, s, func(kv *model.PluginKeyValue) (*model.PluginKeyValue, error) {
return ss.Plugin().SaveOrUpdate(kv)
})
}
// doTestPluginCompareAndSet exercises the CompareAndSet functionality, but abstracts the actual
// call to same to allow reuse with SetWithOptions
func doTestPluginCompareAndSet(t *testing.T, ss store.Store, s SqlSupplier, compareAndSet func(kv *model.PluginKeyValue, oldValue []byte) (bool, error)) {
t.Run("invalid kv", func(t *testing.T) {
_, tearDown := setupKVs(t, ss)
defer tearDown()
kv := &model.PluginKeyValue{
PluginId: "",
Key: model.NewId(),
Value: []byte(model.NewId()),
ExpireAt: 0,
}
ok, err := compareAndSet(kv, nil)
require.NotNil(t, err)
assert.False(t, ok)
appErr, ok := err.(*model.AppError)
require.True(t, ok)
assert.Equal(t, "model.plugin_key_value.is_valid.plugin_id.app_error", appErr.Id)
})
// assertChanged verifies that CompareAndSet successfully changes to the given value.
assertChanged := func(t *testing.T, kv *model.PluginKeyValue, oldValue []byte) {
t.Helper()
ok, err := compareAndSet(kv, oldValue)
require.Nil(t, err)
require.True(t, ok, "should have succeeded to CompareAndSet")
actualKV, nErr := ss.Plugin().Get(kv.PluginId, kv.Key)
require.Nil(t, nErr)
// When tested with KVSetWithOptions, a strict comparison can fail because that
// function accepts a relative time and makes its own call to model.GetMillis(),
// leading to off-by-one issues. All these tests are written with 15+ second
// differences, so allow for an off-by-1000ms in either direction.
require.NotNil(t, actualKV)
expiryDelta := actualKV.ExpireAt - kv.ExpireAt
if expiryDelta > -1000 && expiryDelta < 1000 {
actualKV.ExpireAt = kv.ExpireAt
}
assert.Equal(t, kv, actualKV)
}
// assertUnchanged verifies that CompareAndSet fails, leaving the existing value.
assertUnchanged := func(t *testing.T, kv, existingKV *model.PluginKeyValue, oldValue []byte) {
t.Helper()
ok, err := compareAndSet(kv, oldValue)
require.Nil(t, err)
require.False(t, ok, "should have failed to CompareAndSet")
actualKV, nErr := ss.Plugin().Get(kv.PluginId, kv.Key)
if existingKV == nil {
require.NotNil(t, nErr)
_, ok := nErr.(*store.ErrNotFound)
assert.True(t, ok)
assert.Nil(t, actualKV)
} else {
require.Nil(t, nErr)
assert.Equal(t, existingKV, actualKV)
}
}
// assertRemoved verifies that CompareAndSet successfully removes the given value.
assertRemoved := func(t *testing.T, kv *model.PluginKeyValue, oldValue []byte) {
t.Helper()
ok, err := compareAndSet(kv, oldValue)
require.Nil(t, err)
require.True(t, ok, "should have succeeded to CompareAndSet")
actualKV, nErr := ss.Plugin().Get(kv.PluginId, kv.Key)
_, ok = nErr.(*store.ErrNotFound)
require.NotNil(t, nErr)
assert.True(t, ok)
assert.Nil(t, actualKV)
}
// Non-existent keys and expired keys should behave identically.
for description, setup := range map[string]func(t *testing.T) (*model.PluginKeyValue, func()){
"non-existent key": func(t *testing.T) (*model.PluginKeyValue, func()) {
pluginId, tearDown := setupKVs(t, ss)
kv := &model.PluginKeyValue{
PluginId: pluginId,
Key: model.NewId(),
Value: []byte(model.NewId()),
ExpireAt: 0,
}
return kv, tearDown
},
"expired key": func(t *testing.T) (*model.PluginKeyValue, func()) {
pluginId, tearDown := setupKVs(t, ss)
expiredKV := &model.PluginKeyValue{
PluginId: pluginId,
Key: model.NewId(),
Value: []byte(model.NewId()),
ExpireAt: 1,
}
_, err := ss.Plugin().SaveOrUpdate(expiredKV)
require.Nil(t, err)
return expiredKV, tearDown
},
} {
t.Run(description, func(t *testing.T) {
t.Run("setting a nil value should fail", func(t *testing.T) {
testCases := map[string][]byte{
"given nil old value": nil,
"given non-nil old value": []byte(model.NewId()),
}
for description, oldValue := range testCases {
t.Run(description, func(t *testing.T) {
kv, tearDown := setup(t)
defer tearDown()
kv.Value = nil
assertUnchanged(t, kv, nil, oldValue)
})
}
})
t.Run("setting a non-nil value", func(t *testing.T) {
t.Run("should succeed given non-expiring, nil old value", func(t *testing.T) {
kv, tearDown := setup(t)
defer tearDown()
kv.ExpireAt = 0
assertChanged(t, kv, []byte(nil))
})
t.Run("should succeed given not-yet-expired, nil old value", func(t *testing.T) {
kv, tearDown := setup(t)
defer tearDown()
kv.ExpireAt = model.GetMillis() + 15*1000
assertChanged(t, kv, []byte(nil))
})
t.Run("should fail given expired, nil old value", func(t *testing.T) {
kv, tearDown := setup(t)
defer tearDown()
kv.ExpireAt = 1
assertRemoved(t, kv, []byte(nil))
})
t.Run("should fail given 'different' old value", func(t *testing.T) {
kv, tearDown := setup(t)
defer tearDown()
assertUnchanged(t, kv, nil, []byte(model.NewId()))
})
t.Run("should fail given 'same' old value", func(t *testing.T) {
kv, tearDown := setup(t)
defer tearDown()
assertUnchanged(t, kv, nil, kv.Value)
})
})
})
}
t.Run("existing key", func(t *testing.T) {
setup := func(t *testing.T) (*model.PluginKeyValue, func()) {
pluginId, tearDown := setupKVs(t, ss)
existingKV := &model.PluginKeyValue{
PluginId: pluginId,
Key: model.NewId(),
Value: []byte(model.NewId()),
ExpireAt: 0,
}
_, err := ss.Plugin().SaveOrUpdate(existingKV)
require.Nil(t, err)
return existingKV, tearDown
}
testCases := map[string]bool{
// CompareAndSet should succeed even if the value isn't changing.
"setting the same value": true,
"setting a different value": false,
}
for description, setToSameValue := range testCases {
makeKV := func(t *testing.T, existingKV *model.PluginKeyValue) *model.PluginKeyValue {
kv := &model.PluginKeyValue{
PluginId: existingKV.PluginId,
Key: existingKV.Key,
ExpireAt: existingKV.ExpireAt,
}
if setToSameValue {
kv.Value = existingKV.Value
} else {
kv.Value = []byte(model.NewId())
}
return kv
}
t.Run(description, func(t *testing.T) {
t.Run("should fail", func(t *testing.T) {
testCases := map[string][]byte{
"given nil old value": nil,
"given different old value": []byte(model.NewId()),
}
for description, oldValue := range testCases {
t.Run(description, func(t *testing.T) {
existingKV, tearDown := setup(t)
defer tearDown()
kv := makeKV(t, existingKV)
assertUnchanged(t, kv, existingKV, oldValue)
})
}
})
t.Run("should succeed given same old value", func(t *testing.T) {
existingKV, tearDown := setup(t)
defer tearDown()
kv := makeKV(t, existingKV)
assertChanged(t, kv, existingKV.Value)
})
t.Run("and future expiry should succeed given same old value", func(t *testing.T) {
existingKV, tearDown := setup(t)
defer tearDown()
kv := makeKV(t, existingKV)
kv.ExpireAt = model.GetMillis() + 15*1000
assertChanged(t, kv, existingKV.Value)
})
t.Run("and past expiry should succeed given same old value", func(t *testing.T) {
existingKV, tearDown := setup(t)
defer tearDown()
kv := makeKV(t, existingKV)
kv.ExpireAt = model.GetMillis() - 15*1000
assertRemoved(t, kv, existingKV.Value)
})
})
}
t.Run("setting a nil value", func(t *testing.T) {
makeKV := func(t *testing.T, existingKV *model.PluginKeyValue) *model.PluginKeyValue {
kv := &model.PluginKeyValue{
PluginId: existingKV.PluginId,
Key: existingKV.Key,
Value: existingKV.Value,
ExpireAt: existingKV.ExpireAt,
}
kv.Value = nil
return kv
}
t.Run("should fail", func(t *testing.T) {
testCases := map[string][]byte{
"given nil old value": nil,
"given different old value": []byte(model.NewId()),
}
for description, oldValue := range testCases {
t.Run(description, func(t *testing.T) {
existingKV, tearDown := setup(t)
defer tearDown()
kv := makeKV(t, existingKV)
assertUnchanged(t, kv, existingKV, oldValue)
})
}
})
t.Run("should succeed, deleting, given same old value", func(t *testing.T) {
existingKV, tearDown := setup(t)
defer tearDown()
kv := makeKV(t, existingKV)
assertRemoved(t, kv, existingKV.Value)
})
})
})
}
func testPluginCompareAndSet(t *testing.T, ss store.Store, s SqlSupplier) {
doTestPluginCompareAndSet(t, ss, s, func(kv *model.PluginKeyValue, oldValue []byte) (bool, error) {
return ss.Plugin().CompareAndSet(kv, oldValue)
})
}
func testPluginCompareAndDelete(t *testing.T, ss store.Store, s SqlSupplier) {
t.Run("invalid kv", func(t *testing.T) {
_, tearDown := setupKVs(t, ss)
defer tearDown()
kv := &model.PluginKeyValue{
PluginId: "",
Key: model.NewId(),
Value: []byte(model.NewId()),
ExpireAt: 0,
}
ok, err := ss.Plugin().CompareAndDelete(kv, nil)
require.NotNil(t, err)
assert.False(t, ok)
appErr, ok := err.(*model.AppError)
require.True(t, ok)
assert.Equal(t, "model.plugin_key_value.is_valid.plugin_id.app_error", appErr.Id)
})
t.Run("non-existent key should fail", func(t *testing.T) {
pluginId, tearDown := setupKVs(t, ss)
defer tearDown()
key := model.NewId()
value := model.NewId()
expireAt := int64(0)
kv := &model.PluginKeyValue{
PluginId: pluginId,
Key: key,
Value: []byte(value),
ExpireAt: expireAt,
}
testCases := map[string][]byte{
"given nil old value": nil,
"given non-nil old value": []byte(model.NewId()),
}
for description, oldValue := range testCases {
t.Run(description, func(t *testing.T) {
ok, err := ss.Plugin().CompareAndDelete(kv, oldValue)
require.Nil(t, err)
assert.False(t, ok)
})
}
})
t.Run("expired key should fail", func(t *testing.T) {
pluginId, tearDown := setupKVs(t, ss)
defer tearDown()
key := model.NewId()
value := model.NewId()
expireAt := int64(1)
kv := &model.PluginKeyValue{
PluginId: pluginId,
Key: key,
Value: []byte(value),
ExpireAt: expireAt,
}
_, err := ss.Plugin().SaveOrUpdate(kv)
require.Nil(t, err)
testCases := map[string][]byte{
"given nil old value": nil,
"given different old value": []byte(model.NewId()),
"given same old value": []byte(value),
}
for description, oldValue := range testCases {
t.Run(description, func(t *testing.T) {
ok, err := ss.Plugin().CompareAndDelete(kv, oldValue)
require.Nil(t, err)
assert.False(t, ok)
})
}
})
t.Run("existing key should fail given different old value", func(t *testing.T) {
pluginId, tearDown := setupKVs(t, ss)
defer tearDown()
key := model.NewId()
value := model.NewId()
expireAt := int64(0)
kv := &model.PluginKeyValue{
PluginId: pluginId,
Key: key,
Value: []byte(value),
ExpireAt: expireAt,
}
_, err := ss.Plugin().SaveOrUpdate(kv)
require.Nil(t, err)
oldValue := []byte(model.NewId())
ok, err := ss.Plugin().CompareAndDelete(kv, oldValue)
require.Nil(t, err)
assert.False(t, ok)
})
t.Run("existing key should succeed given same old value", func(t *testing.T) {
pluginId, tearDown := setupKVs(t, ss)
defer tearDown()
key := model.NewId()
value := model.NewId()
expireAt := int64(0)
kv := &model.PluginKeyValue{
PluginId: pluginId,
Key: key,
Value: []byte(value),
ExpireAt: expireAt,
}
_, err := ss.Plugin().SaveOrUpdate(kv)
require.Nil(t, err)
oldValue := []byte(value)
ok, err := ss.Plugin().CompareAndDelete(kv, oldValue)
require.Nil(t, err)
assert.True(t, ok)
})
}
func testPluginSetWithOptions(t *testing.T, ss store.Store, s SqlSupplier) {
t.Run("invalid options", func(t *testing.T) {
_, tearDown := setupKVs(t, ss)
defer tearDown()
pluginId := ""
key := model.NewId()
value := model.NewId()
options := model.PluginKVSetOptions{
Atomic: false,
OldValue: []byte("not-nil"),
}
ok, err := ss.Plugin().SetWithOptions(pluginId, key, []byte(value), options)
require.NotNil(t, err)
assert.False(t, ok)
appErr, ok := err.(*model.AppError)
require.True(t, ok)
require.Equal(t, "model.plugin_kvset_options.is_valid.old_value.app_error", appErr.Id)
})
t.Run("invalid kv", func(t *testing.T) {
_, tearDown := setupKVs(t, ss)
defer tearDown()
pluginId := ""
key := model.NewId()
value := model.NewId()
options := model.PluginKVSetOptions{}
ok, err := ss.Plugin().SetWithOptions(pluginId, key, []byte(value), options)
require.NotNil(t, err)
assert.False(t, ok)
appErr, ok := err.(*model.AppError)
require.True(t, ok)
require.Equal(t, "model.plugin_key_value.is_valid.plugin_id.app_error", appErr.Id)
})
t.Run("atomic", func(t *testing.T) {
doTestPluginCompareAndSet(t, ss, s, func(kv *model.PluginKeyValue, oldValue []byte) (bool, error) {
now := model.GetMillis()
options := model.PluginKVSetOptions{
Atomic: true,
OldValue: oldValue,
}
if kv.ExpireAt != 0 {
options.ExpireInSeconds = (kv.ExpireAt - now) / 1000
}
return ss.Plugin().SetWithOptions(kv.PluginId, kv.Key, kv.Value, options)
})
})
t.Run("non-atomic", func(t *testing.T) {
doTestPluginSaveOrUpdate(t, ss, s, func(kv *model.PluginKeyValue) (*model.PluginKeyValue, error) {
now := model.GetMillis()
options := model.PluginKVSetOptions{
Atomic: false,
}
if kv.ExpireAt != 0 {
options.ExpireInSeconds = (kv.ExpireAt - now) / 1000
}
ok, err := ss.Plugin().SetWithOptions(kv.PluginId, kv.Key, kv.Value, options)
if !ok {
return nil, err
} else {
return kv, err
}
})
})
}
func testPluginGet(t *testing.T, ss store.Store) {
t.Run("no matching key value", func(t *testing.T) {
pluginId := model.NewId()
key := model.NewId()
kv, nErr := ss.Plugin().Get(pluginId, key)
_, ok := nErr.(*store.ErrNotFound)
require.NotNil(t, nErr)
assert.True(t, ok)
assert.Nil(t, kv)
})
t.Run("no-matching key value for plugin id", func(t *testing.T) {
pluginId := model.NewId()
key := model.NewId()
value := model.NewId()
expireAt := int64(0)
kv := &model.PluginKeyValue{
PluginId: pluginId,
Key: key,
Value: []byte(value),
ExpireAt: expireAt,
}
_, err := ss.Plugin().SaveOrUpdate(kv)
require.Nil(t, err)
kv, err = ss.Plugin().Get(model.NewId(), key)
_, ok := err.(*store.ErrNotFound)
require.NotNil(t, err)
assert.True(t, ok)
assert.Nil(t, kv)
})
t.Run("no-matching key value for key", func(t *testing.T) {
pluginId := model.NewId()
key := model.NewId()
value := model.NewId()
expireAt := int64(0)
kv := &model.PluginKeyValue{
PluginId: pluginId,
Key: key,
Value: []byte(value),
ExpireAt: expireAt,
}
_, err := ss.Plugin().SaveOrUpdate(kv)
require.Nil(t, err)
kv, err = ss.Plugin().Get(pluginId, model.NewId())
_, ok := err.(*store.ErrNotFound)
require.NotNil(t, err)
assert.True(t, ok)
assert.Nil(t, kv)
})
t.Run("old expired key value", func(t *testing.T) {
pluginId := model.NewId()
key := model.NewId()
value := model.NewId()
expireAt := int64(1)
kv := &model.PluginKeyValue{
PluginId: pluginId,
Key: key,
Value: []byte(value),
ExpireAt: expireAt,
}
_, err := ss.Plugin().SaveOrUpdate(kv)
require.Nil(t, err)
kv, err = ss.Plugin().Get(pluginId, model.NewId())
_, ok := err.(*store.ErrNotFound)
require.NotNil(t, err)
assert.True(t, ok)
assert.Nil(t, kv)
})
t.Run("recently expired key value", func(t *testing.T) {
pluginId := model.NewId()
key := model.NewId()
value := model.NewId()
expireAt := model.GetMillis() - 15*1000
kv := &model.PluginKeyValue{
PluginId: pluginId,
Key: key,
Value: []byte(value),
ExpireAt: expireAt,
}
_, err := ss.Plugin().SaveOrUpdate(kv)
require.Nil(t, err)
kv, err = ss.Plugin().Get(pluginId, model.NewId())
_, ok := err.(*store.ErrNotFound)
require.NotNil(t, err)
assert.True(t, ok)
assert.Nil(t, kv)
})
t.Run("matching key value, non-expiring", func(t *testing.T) {
pluginId := model.NewId()
key := model.NewId()
value := model.NewId()
expireAt := int64(0)
kv := &model.PluginKeyValue{
PluginId: pluginId,
Key: key,
Value: []byte(value),
ExpireAt: expireAt,
}
_, err := ss.Plugin().SaveOrUpdate(kv)
require.Nil(t, err)
actualKV, err := ss.Plugin().Get(pluginId, key)
require.Nil(t, err)
require.Equal(t, kv, actualKV)
})
t.Run("matching key value, not yet expired", func(t *testing.T) {
pluginId := model.NewId()
key := model.NewId()
value := model.NewId()
expireAt := model.GetMillis() + 15*1000
kv := &model.PluginKeyValue{
PluginId: pluginId,
Key: key,
Value: []byte(value),
ExpireAt: expireAt,
}
_, err := ss.Plugin().SaveOrUpdate(kv)
require.Nil(t, err)
actualKV, err := ss.Plugin().Get(pluginId, key)
require.Nil(t, err)
require.Equal(t, kv, actualKV)
})
}
func testPluginDelete(t *testing.T, ss store.Store) {
t.Run("no matching key value", func(t *testing.T) {
pluginId, tearDown := setupKVs(t, ss)
defer tearDown()
key := model.NewId()
err := ss.Plugin().Delete(pluginId, key)
require.Nil(t, err)
kv, err := ss.Plugin().Get(pluginId, key)
_, ok := err.(*store.ErrNotFound)
require.NotNil(t, err)
assert.True(t, ok)
assert.Nil(t, kv)
})
testCases := []struct {
description string
expireAt int64
}{
{
"expired key value",
model.GetMillis() - 15*1000,
},
{
"never expiring value",
0,
},
{
"not yet expired value",
model.GetMillis() + 15*1000,
},
}
for _, testCase := range testCases {
t.Run(testCase.description, func(t *testing.T) {
pluginId, tearDown := setupKVs(t, ss)
defer tearDown()
key := model.NewId()
value := model.NewId()
expireAt := testCase.expireAt
kv := &model.PluginKeyValue{
PluginId: pluginId,
Key: key,
Value: []byte(value),
ExpireAt: expireAt,
}
_, err := ss.Plugin().SaveOrUpdate(kv)
require.Nil(t, err)
err = ss.Plugin().Delete(pluginId, key)
require.Nil(t, err)
kv, err = ss.Plugin().Get(pluginId, key)
_, ok := err.(*store.ErrNotFound)
require.NotNil(t, err)
assert.True(t, ok)
assert.Nil(t, kv)
})
}
}
func testPluginDeleteAllForPlugin(t *testing.T, ss store.Store) {
setupKVsForDeleteAll := func(t *testing.T) (string, func()) {
pluginId := model.NewId()
otherPluginId := model.NewId()
// otherPluginKV is another key value for another plugin, and used to verify other
// keys aren't modified unintentionally.
otherPluginKV := &model.PluginKeyValue{
PluginId: otherPluginId,
Key: model.NewId(),
Value: []byte(model.NewId()),
ExpireAt: 0,
}
_, err := ss.Plugin().SaveOrUpdate(otherPluginKV)
require.Nil(t, err)
return pluginId, func() {
actualOtherPluginKV, err := ss.Plugin().Get(otherPluginKV.PluginId, otherPluginKV.Key)
require.Nil(t, err, "failed to find other key value from different plugin")
assert.Equal(t, otherPluginKV, actualOtherPluginKV)
}
}
t.Run("no keys to delete", func(t *testing.T) {
pluginId, tearDown := setupKVsForDeleteAll(t)
defer tearDown()
err := ss.Plugin().DeleteAllForPlugin(pluginId)
require.Nil(t, err)
})
t.Run("multiple keys to delete", func(t *testing.T) {
pluginId, tearDown := setupKVsForDeleteAll(t)
defer tearDown()
kv := &model.PluginKeyValue{
PluginId: pluginId,
Key: model.NewId(),
Value: []byte(model.NewId()),
ExpireAt: 0,
}
_, err := ss.Plugin().SaveOrUpdate(kv)
require.Nil(t, err)
kv2 := &model.PluginKeyValue{
PluginId: pluginId,
Key: model.NewId(),
Value: []byte(model.NewId()),
ExpireAt: 0,
}
_, err = ss.Plugin().SaveOrUpdate(kv2)
require.Nil(t, err)
err = ss.Plugin().DeleteAllForPlugin(pluginId)
require.Nil(t, err)
_, err = ss.Plugin().Get(kv.PluginId, kv.Key)
_, ok := err.(*store.ErrNotFound)
require.NotNil(t, err)
assert.True(t, ok)
_, err = ss.Plugin().Get(kv.PluginId, kv2.Key)
_, ok = err.(*store.ErrNotFound)
require.NotNil(t, err)
assert.True(t, ok)
})
}
func testPluginDeleteAllExpired(t *testing.T, ss store.Store) {
t.Run("no keys", func(t *testing.T) {
err := ss.Plugin().DeleteAllExpired()
require.Nil(t, err)
})
t.Run("no expiring keys to delete", func(t *testing.T) {
pluginIdA := model.NewId()
pluginIdB := model.NewId()
kvA1 := &model.PluginKeyValue{
PluginId: pluginIdA,
Key: model.NewId(),
Value: []byte(model.NewId()),
ExpireAt: 0,
}
_, err := ss.Plugin().SaveOrUpdate(kvA1)
require.Nil(t, err)
kvA2 := &model.PluginKeyValue{
PluginId: pluginIdA,
Key: model.NewId(),
Value: []byte(model.NewId()),
ExpireAt: 0,
}
_, err = ss.Plugin().SaveOrUpdate(kvA2)
require.Nil(t, err)
kvB1 := &model.PluginKeyValue{
PluginId: pluginIdB,
Key: model.NewId(),
Value: []byte(model.NewId()),
ExpireAt: 0,
}
_, err = ss.Plugin().SaveOrUpdate(kvB1)
require.Nil(t, err)
kvB2 := &model.PluginKeyValue{
PluginId: pluginIdB,
Key: model.NewId(),
Value: []byte(model.NewId()),
ExpireAt: 0,
}
_, err = ss.Plugin().SaveOrUpdate(kvB2)
require.Nil(t, err)
err = ss.Plugin().DeleteAllExpired()
require.Nil(t, err)
actualKVA1, err := ss.Plugin().Get(pluginIdA, kvA1.Key)
require.Nil(t, err)
assert.Equal(t, kvA1, actualKVA1)
actualKVA2, err := ss.Plugin().Get(pluginIdA, kvA2.Key)
require.Nil(t, err)
assert.Equal(t, kvA2, actualKVA2)
actualKVB1, err := ss.Plugin().Get(pluginIdB, kvB1.Key)
require.Nil(t, err)
assert.Equal(t, kvB1, actualKVB1)
actualKVB2, err := ss.Plugin().Get(pluginIdB, kvB2.Key)
require.Nil(t, err)
assert.Equal(t, kvB2, actualKVB2)
})
t.Run("no expired keys to delete", func(t *testing.T) {
pluginIdA := model.NewId()
pluginIdB := model.NewId()
kvA1 := &model.PluginKeyValue{
PluginId: pluginIdA,
Key: model.NewId(),
Value: []byte(model.NewId()),
ExpireAt: model.GetMillis() + 15*1000,
}
_, err := ss.Plugin().SaveOrUpdate(kvA1)
require.Nil(t, err)
kvA2 := &model.PluginKeyValue{
PluginId: pluginIdA,
Key: model.NewId(),
Value: []byte(model.NewId()),
ExpireAt: model.GetMillis() + 15*1000,
}
_, err = ss.Plugin().SaveOrUpdate(kvA2)
require.Nil(t, err)
kvB1 := &model.PluginKeyValue{
PluginId: pluginIdB,
Key: model.NewId(),
Value: []byte(model.NewId()),
ExpireAt: model.GetMillis() + 15*1000,
}
_, err = ss.Plugin().SaveOrUpdate(kvB1)
require.Nil(t, err)
kvB2 := &model.PluginKeyValue{
PluginId: pluginIdB,
Key: model.NewId(),
Value: []byte(model.NewId()),
ExpireAt: model.GetMillis() + 15*1000,
}
_, err = ss.Plugin().SaveOrUpdate(kvB2)
require.Nil(t, err)
err = ss.Plugin().DeleteAllExpired()
require.Nil(t, err)
actualKVA1, err := ss.Plugin().Get(pluginIdA, kvA1.Key)
require.Nil(t, err)
assert.Equal(t, kvA1, actualKVA1)
actualKVA2, err := ss.Plugin().Get(pluginIdA, kvA2.Key)
require.Nil(t, err)
assert.Equal(t, kvA2, actualKVA2)
actualKVB1, err := ss.Plugin().Get(pluginIdB, kvB1.Key)
require.Nil(t, err)
assert.Equal(t, kvB1, actualKVB1)
actualKVB2, err := ss.Plugin().Get(pluginIdB, kvB2.Key)
require.Nil(t, err)
assert.Equal(t, kvB2, actualKVB2)
})
t.Run("some expired keys to delete", func(t *testing.T) {
pluginIdA := model.NewId()
pluginIdB := model.NewId()
kvA1 := &model.PluginKeyValue{
PluginId: pluginIdA,
Key: model.NewId(),
Value: []byte(model.NewId()),
ExpireAt: model.GetMillis() + 15*1000,
}
_, err := ss.Plugin().SaveOrUpdate(kvA1)
require.Nil(t, err)
expiredKVA2 := &model.PluginKeyValue{
PluginId: pluginIdA,
Key: model.NewId(),
Value: []byte(model.NewId()),
ExpireAt: model.GetMillis() - 15*1000,
}
_, err = ss.Plugin().SaveOrUpdate(expiredKVA2)
require.Nil(t, err)
kvB1 := &model.PluginKeyValue{
PluginId: pluginIdB,
Key: model.NewId(),
Value: []byte(model.NewId()),
ExpireAt: model.GetMillis() + 15*1000,
}
_, err = ss.Plugin().SaveOrUpdate(kvB1)
require.Nil(t, err)
expiredKVB2 := &model.PluginKeyValue{
PluginId: pluginIdB,
Key: model.NewId(),
Value: []byte(model.NewId()),
ExpireAt: model.GetMillis() - 15*1000,
}
_, err = ss.Plugin().SaveOrUpdate(expiredKVB2)
require.Nil(t, err)
err = ss.Plugin().DeleteAllExpired()
require.Nil(t, err)
actualKVA1, err := ss.Plugin().Get(pluginIdA, kvA1.Key)
require.Nil(t, err)
assert.Equal(t, kvA1, actualKVA1)
actualKVA2, err := ss.Plugin().Get(pluginIdA, expiredKVA2.Key)
_, ok := err.(*store.ErrNotFound)
require.NotNil(t, err)
assert.True(t, ok)
assert.Nil(t, actualKVA2)
actualKVB1, err := ss.Plugin().Get(pluginIdB, kvB1.Key)
require.Nil(t, err)
assert.Equal(t, kvB1, actualKVB1)
actualKVB2, err := ss.Plugin().Get(pluginIdB, expiredKVB2.Key)
_, ok = err.(*store.ErrNotFound)
require.NotNil(t, err)
assert.True(t, ok)
assert.Nil(t, actualKVB2)
})
}
func testPluginList(t *testing.T, ss store.Store) {
t.Run("no key values", func(t *testing.T) {
_, tearDown := setupKVs(t, ss)
defer tearDown()
// Ignore the pluginId setup by setupKVs
pluginId := model.NewId()
keys, err := ss.Plugin().List(pluginId, 0, 100)
require.Nil(t, err)
assert.Empty(t, keys)
})
t.Run("single key", func(t *testing.T) {
_, tearDown := setupKVs(t, ss)
defer tearDown()
// Ignore the pluginId setup by setupKVs
pluginId := model.NewId()
kv := &model.PluginKeyValue{
PluginId: pluginId,
Key: model.NewId(),
Value: []byte(model.NewId()),
ExpireAt: 0,
}
_, err := ss.Plugin().SaveOrUpdate(kv)
require.Nil(t, err)
keys, err := ss.Plugin().List(pluginId, 0, 100)
require.Nil(t, err)
require.Len(t, keys, 1)
assert.Equal(t, kv.Key, keys[0])
})
t.Run("multiple keys", func(t *testing.T) {
_, tearDown := setupKVs(t, ss)
defer tearDown()
// Ignore the pluginId setup by setupKVs
pluginId := model.NewId()
var keys []string
for i := 0; i < 150; i++ {
key := model.NewId()
kv := &model.PluginKeyValue{
PluginId: pluginId,
Key: key,
Value: []byte(model.NewId()),
ExpireAt: 0,
}
_, err := ss.Plugin().SaveOrUpdate(kv)
require.Nil(t, err)
keys = append(keys, key)
}
sort.Strings(keys)
keys1, err := ss.Plugin().List(pluginId, 0, 100)
require.Nil(t, err)
require.Len(t, keys1, 100)
keys2, err := ss.Plugin().List(pluginId, 100, 100)
require.Nil(t, err)
require.Len(t, keys2, 50)
actualKeys := append(keys1, keys2...)
sort.Strings(actualKeys)
assert.Equal(t, keys, actualKeys)
})
t.Run("multiple keys, some expiring", func(t *testing.T) {
_, tearDown := setupKVs(t, ss)
defer tearDown()
// Ignore the pluginId setup by setupKVs
pluginId := model.NewId()
var keys []string
var expiredKeys []string
now := model.GetMillis()
for i := 0; i < 150; i++ {
key := model.NewId()
var expireAt int64
if i%10 == 0 {
// Expire keys 0, 10, 20, ...
expireAt = 1
} else if (i+5)%10 == 0 {
// Mark for future expiry keys 5, 15, 25, ...
expireAt = now + 5*60*1000
}
kv := &model.PluginKeyValue{
PluginId: pluginId,
Key: key,
Value: []byte(model.NewId()),
ExpireAt: expireAt,
}
_, err := ss.Plugin().SaveOrUpdate(kv)
require.Nil(t, err)
if expireAt == 0 || expireAt > now {
keys = append(keys, key)
} else {
expiredKeys = append(expiredKeys, key)
}
}
sort.Strings(keys)
keys1, err := ss.Plugin().List(pluginId, 0, 100)
require.Nil(t, err)
require.Len(t, keys1, 100)
keys2, err := ss.Plugin().List(pluginId, 100, 100)
require.Nil(t, err)
require.Len(t, keys2, 35)
actualKeys := append(keys1, keys2...)
sort.Strings(actualKeys)
assert.Equal(t, keys, actualKeys)
})
t.Run("offsets and limits", func(t *testing.T) {
_, tearDown := setupKVs(t, ss)
defer tearDown()
// Ignore the pluginId setup by setupKVs
pluginId := model.NewId()
var keys []string
for i := 0; i < 150; i++ {
key := model.NewId()
kv := &model.PluginKeyValue{
PluginId: pluginId,
Key: key,
Value: []byte(model.NewId()),
ExpireAt: 0,
}
_, err := ss.Plugin().SaveOrUpdate(kv)
require.Nil(t, err)
keys = append(keys, key)
}
sort.Strings(keys)
t.Run("default limit", func(t *testing.T) {
keys1, err := ss.Plugin().List(pluginId, 0, 0)
require.Nil(t, err)
require.Len(t, keys1, 10)
})
t.Run("offset 0, limit 1", func(t *testing.T) {
keys2, err := ss.Plugin().List(pluginId, 0, 1)
require.Nil(t, err)
require.Len(t, keys2, 1)
})
t.Run("offset 1, limit 1", func(t *testing.T) {
keys2, err := ss.Plugin().List(pluginId, 1, 1)
require.Nil(t, err)
require.Len(t, keys2, 1)
})
})
} | store/storetest/plugin_store.go | 0.592431 | 0.434641 | plugin_store.go | starcoder |
package restructure
import (
"fmt"
"reflect"
)
var (
posType = reflect.TypeOf(Pos(0))
emptyType = reflect.TypeOf(struct{}{})
stringType = reflect.TypeOf("")
byteSliceType = reflect.TypeOf([]byte{})
submatchType = reflect.TypeOf(Submatch{})
scalarTypes = []reflect.Type{
emptyType,
stringType,
byteSliceType,
submatchType,
}
)
// determines whether t is a scalar type or a pointer to a scalar type
func isScalar(t reflect.Type) bool {
if t.Kind() == reflect.Ptr {
t = t.Elem()
}
for _, u := range scalarTypes {
if t == u {
return true
}
}
return false
}
// determines whether t is a struct type or a pointer to a struct type
func isStruct(t reflect.Type) bool {
if t.Kind() == reflect.Ptr {
t = t.Elem()
}
return t.Kind() == reflect.Struct
}
// ensureAlloc replaces nil pointers with newly allocated objects
func ensureAlloc(dest reflect.Value) reflect.Value {
if dest.Kind() == reflect.Ptr {
if dest.IsNil() {
dest.Set(reflect.New(dest.Type().Elem()))
}
return dest.Elem()
}
return dest
}
// inflate the results of a match into a string
func inflateScalar(dest reflect.Value, match *match, captureIndex int, role Role) error {
if captureIndex == -1 {
// This means the field generated a regex but we did not want the results
return nil
}
// Get the subcapture for this field
subcapture := match.captures[captureIndex]
if !subcapture.wasMatched() {
// This means the subcapture was optional and was not matched
return nil
}
// Get the matched bytes
buf := match.input[subcapture.begin:subcapture.end]
// If dest is a nil pointer then allocate a new instance and assign the pointer to dest
dest = ensureAlloc(dest)
// Deal with each recognized type
switch role {
case StringScalarRole:
dest.SetString(string(buf))
return nil
case ByteSliceScalarRole:
dest.SetBytes(buf)
return nil
case SubmatchScalarRole:
submatch := dest.Addr().Interface().(*Submatch)
submatch.Begin = Pos(subcapture.begin)
submatch.End = Pos(subcapture.end)
submatch.Bytes = buf
return nil
}
return fmt.Errorf("unable to capture into %s", dest.Type().String())
}
// inflate the position of a match into a Pos
func inflatePos(dest reflect.Value, match *match, captureIndex int) error {
if captureIndex == -1 {
// This means the field generated a regex but we did not want the results
return nil
}
// Get the subcapture for this field
subcapture := match.captures[captureIndex]
if !subcapture.wasMatched() {
// This means the subcapture was optional and was not matched
return nil
}
// If dest is a nil pointer then allocate a new instance and assign the pointer to dest
dest.SetInt(int64(subcapture.begin))
return nil
}
// inflate the results of a match into a struct
func inflateStruct(dest reflect.Value, match *match, structure *Struct) error {
// Get the subcapture for this field
subcapture := match.captures[structure.capture]
if !subcapture.wasMatched() {
return nil
}
// If the field is a nil pointer then allocate an instance and assign pointer to dest
dest = ensureAlloc(dest)
// Inflate values into the struct fields
for _, field := range structure.fields {
switch field.role {
case PosRole:
val := dest.FieldByIndex(field.index)
if err := inflatePos(val, match, field.capture); err != nil {
return err
}
case StringScalarRole, ByteSliceScalarRole, SubmatchScalarRole:
val := dest.FieldByIndex(field.index)
if err := inflateScalar(val, match, field.capture, field.role); err != nil {
return err
}
case SubstructRole:
val := dest.FieldByIndex(field.index)
if err := inflateStruct(val, match, field.child); err != nil {
return err
}
}
}
return nil
} | inflate.go | 0.690768 | 0.448607 | inflate.go | starcoder |
package expr
import (
"github.com/genjidb/genji/document"
"github.com/genjidb/genji/internal/environment"
"github.com/genjidb/genji/internal/sql/scanner"
"github.com/genjidb/genji/internal/stringutil"
"github.com/genjidb/genji/types"
)
// A cmpOp is a comparison operator.
type cmpOp struct {
*simpleOperator
}
// newCmpOp creates a comparison operator.
func newCmpOp(a, b Expr, t scanner.Token) *cmpOp {
return &cmpOp{&simpleOperator{a, b, t}}
}
// Eval compares a and b together using the operator specified when constructing the CmpOp
// and returns the result of the comparison.
// Comparing with NULL always evaluates to NULL.
func (op *cmpOp) Eval(env *environment.Environment) (types.Value, error) {
return op.simpleOperator.eval(env, func(a, b types.Value) (types.Value, error) {
if a.Type() == types.NullValue || b.Type() == types.NullValue {
return NullLiteral, nil
}
ok, err := op.compare(a, b)
if ok {
return TrueLiteral, err
}
return FalseLiteral, err
})
}
func (op *cmpOp) compare(l, r types.Value) (bool, error) {
switch op.Tok {
case scanner.EQ:
return types.IsEqual(l, r)
case scanner.NEQ:
return types.IsNotEqual(l, r)
case scanner.GT:
return types.IsGreaterThan(l, r)
case scanner.GTE:
return types.IsGreaterThanOrEqual(l, r)
case scanner.LT:
return types.IsLesserThan(l, r)
case scanner.LTE:
return types.IsLesserThanOrEqual(l, r)
default:
panic(stringutil.Sprintf("unknown token %v", op.Tok))
}
}
// Eq creates an expression that returns true if a equals b.
func Eq(a, b Expr) Expr {
return newCmpOp(a, b, scanner.EQ)
}
// Neq creates an expression that returns true if a equals b.
func Neq(a, b Expr) Expr {
return newCmpOp(a, b, scanner.NEQ)
}
// Gt creates an expression that returns true if a is greater than b.
func Gt(a, b Expr) Expr {
return newCmpOp(a, b, scanner.GT)
}
// Gte creates an expression that returns true if a is greater than or equal to b.
func Gte(a, b Expr) Expr {
return newCmpOp(a, b, scanner.GTE)
}
// Lt creates an expression that returns true if a is lesser than b.
func Lt(a, b Expr) Expr {
return newCmpOp(a, b, scanner.LT)
}
// Lte creates an expression that returns true if a is lesser than or equal to b.
func Lte(a, b Expr) Expr {
return newCmpOp(a, b, scanner.LTE)
}
type BetweenOperator struct {
*simpleOperator
X Expr
}
// Between returns a function that creates a BETWEEN operator that
// returns true if x is between a and b.
func Between(a Expr) func(x, b Expr) Expr {
return func(x, b Expr) Expr {
return &BetweenOperator{&simpleOperator{a, b, scanner.BETWEEN}, x}
}
}
func (op *BetweenOperator) Eval(env *environment.Environment) (types.Value, error) {
x, err := op.X.Eval(env)
if err != nil {
return FalseLiteral, err
}
return op.simpleOperator.eval(env, func(a, b types.Value) (types.Value, error) {
if a.Type() == types.NullValue || b.Type() == types.NullValue {
return NullLiteral, nil
}
ok, err := types.IsGreaterThanOrEqual(x, a)
if !ok || err != nil {
return FalseLiteral, err
}
ok, err = types.IsLesserThanOrEqual(x, b)
if !ok || err != nil {
return FalseLiteral, err
}
return TrueLiteral, nil
})
}
func (op *BetweenOperator) String() string {
return stringutil.Sprintf("%v BETWEEN %v AND %v", op.X, op.a, op.b)
}
// IsComparisonOperator returns true if e is one of
// =, !=, >, >=, <, <=, IS, IS NOT, IN, or NOT IN operators.
func IsComparisonOperator(op Operator) bool {
switch op.(type) {
case *cmpOp, *IsOperator, *IsNotOperator, *InOperator, *NotInOperator, *LikeOperator, *NotLikeOperator, *BetweenOperator:
return true
}
return false
}
type InOperator struct {
*simpleOperator
}
// In creates an expression that evaluates to the result of a IN b.
func In(a, b Expr) Expr {
return &InOperator{&simpleOperator{a, b, scanner.IN}}
}
func (op *InOperator) Eval(env *environment.Environment) (types.Value, error) {
return op.simpleOperator.eval(env, func(a, b types.Value) (types.Value, error) {
if a.Type() == types.NullValue || b.Type() == types.NullValue {
return NullLiteral, nil
}
if b.Type() != types.ArrayValue {
return FalseLiteral, nil
}
ok, err := document.ArrayContains(b.V().(types.Array), a)
if err != nil {
return NullLiteral, err
}
if ok {
return TrueLiteral, nil
}
return FalseLiteral, nil
})
}
type NotInOperator struct {
InOperator
}
// NotIn creates an expression that evaluates to the result of a NOT IN b.
func NotIn(a, b Expr) Expr {
return &NotInOperator{InOperator{&simpleOperator{a, b, scanner.NIN}}}
}
func (op *NotInOperator) Eval(env *environment.Environment) (types.Value, error) {
return invertBoolResult(op.InOperator.Eval)(env)
}
func (op *NotInOperator) String() string {
return stringutil.Sprintf("%v NOT IN %v", op.a, op.b)
}
type IsOperator struct {
*simpleOperator
}
// Is creates an expression that evaluates to the result of a IS b.
func Is(a, b Expr) Expr {
return &IsOperator{&simpleOperator{a, b, scanner.IN}}
}
func (op *IsOperator) Eval(env *environment.Environment) (types.Value, error) {
return op.simpleOperator.eval(env, func(a, b types.Value) (types.Value, error) {
ok, err := types.IsEqual(a, b)
if err != nil {
return NullLiteral, err
}
if ok {
return TrueLiteral, nil
}
return FalseLiteral, nil
})
}
type IsNotOperator struct {
*simpleOperator
}
// IsNot creates an expression that evaluates to the result of a IS NOT b.
func IsNot(a, b Expr) Expr {
return &IsNotOperator{&simpleOperator{a, b, scanner.ISN}}
}
func (op *IsNotOperator) Eval(env *environment.Environment) (types.Value, error) {
return op.simpleOperator.eval(env, func(a, b types.Value) (types.Value, error) {
ok, err := types.IsNotEqual(a, b)
if err != nil {
return NullLiteral, err
}
if ok {
return TrueLiteral, nil
}
return FalseLiteral, nil
})
}
func (op *IsNotOperator) String() string {
return stringutil.Sprintf("%v IS NOT %v", op.a, op.b)
} | internal/expr/comparison.go | 0.765944 | 0.454775 | comparison.go | starcoder |
package basic
import "strings"
// MapIONumber is template to generate itself for different combination of data type.
func MapIONumber() string {
return `
func TestMap<FINPUT_TYPE><FOUTPUT_TYPE>(t *testing.T) {
// Test : add 1 to the list
expectedList := []<OUTPUT_TYPE>{2, 3, 4}
newList := Map<FINPUT_TYPE><FOUTPUT_TYPE>(plusOne<FINPUT_TYPE><FOUTPUT_TYPE>, []<INPUT_TYPE>{1, 2, 3})
if newList[0] != expectedList[0] || newList[1] != expectedList[1] || newList[2] != expectedList[2] {
t.Errorf("Map<FINPUT_TYPE><FOUTPUT_TYPE> failed. expected=%v, actual=%v", expectedList, newList)
}
if len(Map<FINPUT_TYPE><FOUTPUT_TYPE>(nil, nil)) > 0 {
t.Errorf("Map<FINPUT_TYPE><FOUTPUT_TYPE> failed")
}
if len(Map<FINPUT_TYPE><FOUTPUT_TYPE>(nil, []<INPUT_TYPE>{})) > 0 {
t.Errorf("Map<FINPUT_TYPE><FOUTPUT_TYPE> failed")
}
reflect.TypeOf("Nandeshwar") // Leaving it here to make use of import reflect
}
`
}
// MapIOStrNumber is template to generate itself for different combination of data type.
func MapIOStrNumber() string {
return `
func TestMap<FINPUT_TYPE><FOUTPUT_TYPE>(t *testing.T) {
// Test : someLogic
expectedList := []<OUTPUT_TYPE>{10}
newList := Map<FINPUT_TYPE><FOUTPUT_TYPE>(someLogic<FINPUT_TYPE><FOUTPUT_TYPE>, []<INPUT_TYPE>{"ten"})
if newList[0] != expectedList[0] {
t.Errorf("Map<FINPUT_TYPE><FOUTPUT_TYPE> failed. expected=%v, actual=%v", expectedList, newList)
}
if len(Map<FINPUT_TYPE><FOUTPUT_TYPE>(nil, nil)) > 0 {
t.Errorf("Map<FINPUT_TYPE><FOUTPUT_TYPE> failed")
}
if len(Map<FINPUT_TYPE><FOUTPUT_TYPE>(nil, []<INPUT_TYPE>{})) > 0 {
t.Errorf("Map<FINPUT_TYPE><FOUTPUT_TYPE> failed")
}
reflect.TypeOf("Nandeshwar") // Leaving it here to make use of import reflect
}
`
}
// MapIONumberStr is template to generate itself for different combination of data type.
func MapIONumberStr() string {
return `
func TestMap<FINPUT_TYPE><FOUTPUT_TYPE>(t *testing.T) {
// Test : someLogic
expectedList := []<OUTPUT_TYPE>{"10"}
newList := Map<FINPUT_TYPE><FOUTPUT_TYPE>(someLogic<FINPUT_TYPE><FOUTPUT_TYPE>, []<INPUT_TYPE>{10})
if newList[0] != expectedList[0] {
t.Errorf("Map<FINPUT_TYPE><FOUTPUT_TYPE> failed. expected=%v, actual=%v", expectedList, newList)
}
if len(Map<FINPUT_TYPE><FOUTPUT_TYPE>(nil, nil)) > 0 {
t.Errorf("Map<FINPUT_TYPE><FOUTPUT_TYPE> failed")
}
if len(Map<FINPUT_TYPE><FOUTPUT_TYPE>(nil, []<INPUT_TYPE>{})) > 0 {
t.Errorf("Map<FINPUT_TYPE><FOUTPUT_TYPE> failed")
}
reflect.TypeOf("Nandeshwar") // Leaving it here to make use of import reflect
}
`
}
// MapIONumberBool is template to generate itself for different combination of data type.
func MapIONumberBool() string {
return `
func TestMap<FINPUT_TYPE><FOUTPUT_TYPE>(t *testing.T) {
// Test : someLogic
expectedList := []<OUTPUT_TYPE>{true, false}
newList := Map<FINPUT_TYPE><FOUTPUT_TYPE>(someLogic<FINPUT_TYPE><FOUTPUT_TYPE>, []<INPUT_TYPE>{10, 0})
if newList[0] != expectedList[0] && newList[1] != expectedList[1] {
t.Errorf("Map<FINPUT_TYPE><FOUTPUT_TYPE> failed. expected=%v, actual=%v", expectedList, newList)
}
if len(Map<FINPUT_TYPE><FOUTPUT_TYPE>(nil, nil)) > 0 {
t.Errorf("Map<FINPUT_TYPE><FOUTPUT_TYPE> failed")
}
if len(Map<FINPUT_TYPE><FOUTPUT_TYPE>(nil, []<INPUT_TYPE>{})) > 0 {
t.Errorf("Map<FINPUT_TYPE><FOUTPUT_TYPE> failed")
}
reflect.TypeOf("Nandeshwar") // Leaving it here to make use of import reflect
}
`
}
// MapIOStrBool is template to generate itself for different combination of data type.
func MapIOStrBool() string {
return `
func TestMap<FINPUT_TYPE><FOUTPUT_TYPE>(t *testing.T) {
// Test : someLogic
expectedList := []<OUTPUT_TYPE>{true, false}
newList := Map<FINPUT_TYPE><FOUTPUT_TYPE>(someLogic<FINPUT_TYPE><FOUTPUT_TYPE>, []<INPUT_TYPE>{"10", "0"})
if newList[0] != expectedList[0] && newList[1] != expectedList[1] {
t.Errorf("Map<FINPUT_TYPE><FOUTPUT_TYPE> failed. expected=%v, actual=%v", expectedList, newList)
}
if len(Map<FINPUT_TYPE><FOUTPUT_TYPE>(nil, nil)) > 0 {
t.Errorf("Map<FINPUT_TYPE><FOUTPUT_TYPE> failed")
}
if len(Map<FINPUT_TYPE><FOUTPUT_TYPE>(nil, []<INPUT_TYPE>{})) > 0 {
t.Errorf("Map<FINPUT_TYPE><FOUTPUT_TYPE> failed")
}
reflect.TypeOf("Nandeshwar") // Leaving it here to make use of import reflect
}
`
}
// MapIOBoolNumber is template to generate itself for different combination of data type.
func MapIOBoolNumber() string {
return `
func TestMap<FINPUT_TYPE><FOUTPUT_TYPE>(t *testing.T) {
// Test : someLogic
expectedList := []<OUTPUT_TYPE>{10, 0}
newList := Map<FINPUT_TYPE><FOUTPUT_TYPE>(someLogic<FINPUT_TYPE><FOUTPUT_TYPE>, []<INPUT_TYPE>{true, false})
if newList[0] != expectedList[0] && newList[1] != expectedList[1] {
t.Errorf("Map<FINPUT_TYPE><FOUTPUT_TYPE> failed. expected=%v, actual=%v", expectedList, newList)
}
if len(Map<FINPUT_TYPE><FOUTPUT_TYPE>(nil, nil)) > 0 {
t.Errorf("Map<FINPUT_TYPE><FOUTPUT_TYPE> failed")
}
if len(Map<FINPUT_TYPE><FOUTPUT_TYPE>(nil, []<INPUT_TYPE>{})) > 0 {
t.Errorf("Map<FINPUT_TYPE><FOUTPUT_TYPE> failed")
}
reflect.TypeOf("Nandeshwar") // Leaving it here to make use of import reflect
}
`
}
// MapIOBoolStr is template to generate itself for different combination of data type.
func MapIOBoolStr() string {
return `
func TestMap<FINPUT_TYPE><FOUTPUT_TYPE>(t *testing.T) {
// Test : someLogic
expectedList := []<OUTPUT_TYPE>{"10", "0"}
newList := Map<FINPUT_TYPE><FOUTPUT_TYPE>(someLogic<FINPUT_TYPE><FOUTPUT_TYPE>, []<INPUT_TYPE>{true, false})
if newList[0] != expectedList[0] && newList[1] != expectedList[1] {
t.Errorf("Map<FINPUT_TYPE><FOUTPUT_TYPE> failed. expected=%v, actual=%v", expectedList, newList)
}
if len(Map<FINPUT_TYPE><FOUTPUT_TYPE>(nil, nil)) > 0 {
t.Errorf("Map<FINPUT_TYPE><FOUTPUT_TYPE> failed")
}
if len(Map<FINPUT_TYPE><FOUTPUT_TYPE>(nil, []<INPUT_TYPE>{})) > 0 {
t.Errorf("Map<FINPUT_TYPE><FOUTPUT_TYPE> failed")
}
reflect.TypeOf("Nandeshwar") // Leaving it here to make use of import reflect
}
`
}
// MapIONumberErr is template to generate itself for different combination of data type.
func MapIONumberErr() string {
return `
func TestMap<FINPUT_TYPE><FOUTPUT_TYPE>Err(t *testing.T) {
// Test : add 1 to the list
expectedList := []<OUTPUT_TYPE>{2, 3, 6}
newList, _ := Map<FINPUT_TYPE><FOUTPUT_TYPE>Err(plusOne<FINPUT_TYPE><FOUTPUT_TYPE>Err, []<INPUT_TYPE>{1, 2, 5})
if newList[0] != expectedList[0] || newList[1] != expectedList[1] || newList[2] != expectedList[2] {
t.Errorf("Map<FINPUT_TYPE><FOUTPUT_TYPE>Err failed. expected=%v, actual=%v", expectedList, newList)
}
r, _ := Map<FINPUT_TYPE><FOUTPUT_TYPE>Err(nil, nil)
if len(r) > 0 {
t.Errorf("Map<FINPUT_TYPE><FOUTPUT_TYPE>Err failed")
}
r, _ = Map<FINPUT_TYPE><FOUTPUT_TYPE>Err(nil, []<INPUT_TYPE>{})
if len(r) > 0 {
t.Errorf("Map<FINPUT_TYPE><FOUTPUT_TYPE>Err failed")
}
_, err := Map<FINPUT_TYPE><FOUTPUT_TYPE>Err(plusOne<FINPUT_TYPE><FOUTPUT_TYPE>Err, []<INPUT_TYPE>{1, 2, 3})
if err == nil {
t.Errorf("Map<FINPUT_TYPE><FOUTPUT_TYPE>Err failed")
}
reflect.TypeOf("Nandeshwar") // Leaving it here to make use of import reflect
}
`
}
// MapIOStrNumberErr is template to generate itself for different combination of data type.
func MapIOStrNumberErr() string {
return `
func TestMap<FINPUT_TYPE><FOUTPUT_TYPE>Err(t *testing.T) {
// Test : someLogic
expectedList := []<OUTPUT_TYPE>{10}
newList, _ := Map<FINPUT_TYPE><FOUTPUT_TYPE>Err(someLogic<FINPUT_TYPE><FOUTPUT_TYPE>Err, []<INPUT_TYPE>{"ten"})
if newList[0] != expectedList[0] {
t.Errorf("Map<FINPUT_TYPE><FOUTPUT_TYPE>Err failed. expected=%v, actual=%v", expectedList, newList)
}
r, _ := Map<FINPUT_TYPE><FOUTPUT_TYPE>Err(nil, nil)
if len(r) > 0 {
t.Errorf("Map<FINPUT_TYPE><FOUTPUT_TYPE>Err failed")
}
r, _ = Map<FINPUT_TYPE><FOUTPUT_TYPE>Err(nil, []<INPUT_TYPE>{})
if len(r) > 0 {
t.Errorf("Map<FINPUT_TYPE><FOUTPUT_TYPE>Err failed")
}
_, err := Map<FINPUT_TYPE><FOUTPUT_TYPE>Err(someLogic<FINPUT_TYPE><FOUTPUT_TYPE>Err, []<INPUT_TYPE>{"0"})
if err == nil {
t.Errorf("Map<FINPUT_TYPE><FOUTPUT_TYPE>Err failed")
}
reflect.TypeOf("Nandeshwar") // Leaving it here to make use of import reflect
}
func someLogic<FINPUT_TYPE><FOUTPUT_TYPE>Err(num <INPUT_TYPE>) (<OUTPUT_TYPE>, error) {
if num == "0" {
return 0, errors.New("0 is invalid number for this test")
}
if num == "ten" {
return <OUTPUT_TYPE>(10), nil
}
return 0, nil
}
`
}
// MapIONumberStrErr is template to generate itself for different combination of data type.
func MapIONumberStrErr() string {
return `
func TestMap<FINPUT_TYPE><FOUTPUT_TYPE>Err(t *testing.T) {
// Test : someLogic
expectedList := []<OUTPUT_TYPE>{"10"}
newList, _ := Map<FINPUT_TYPE><FOUTPUT_TYPE>Err(someLogic<FINPUT_TYPE><FOUTPUT_TYPE>Err, []<INPUT_TYPE>{10})
if newList[0] != expectedList[0] {
t.Errorf("Map<FINPUT_TYPE><FOUTPUT_TYPE>Err failed. expected=%v, actual=%v", expectedList, newList)
}
r, _ := Map<FINPUT_TYPE><FOUTPUT_TYPE>Err(nil, nil)
if len(r) > 0 {
t.Errorf("Map<FINPUT_TYPE><FOUTPUT_TYPE> failed")
}
r, _ = Map<FINPUT_TYPE><FOUTPUT_TYPE>Err(nil, []<INPUT_TYPE>{})
if len(r) > 0 {
t.Errorf("Map<FINPUT_TYPE><FOUTPUT_TYPE>Err failed")
}
_, err := Map<FINPUT_TYPE><FOUTPUT_TYPE>Err(someLogic<FINPUT_TYPE><FOUTPUT_TYPE>Err, []<INPUT_TYPE>{0})
if err == nil {
t.Errorf("Map<FINPUT_TYPE><FOUTPUT_TYPE>Err failed")
}
reflect.TypeOf("Nandeshwar") // Leaving it here to make use of import reflect
}
func someLogic<FINPUT_TYPE><FOUTPUT_TYPE>Err(num <INPUT_TYPE>) (<OUTPUT_TYPE>, error) {
if num == 0 {
return "", errors.New("0 is not valid number for this test")
}
if num == 10 {
return string("10"), nil
}
return "0", nil
}
`
}
// MapIONumberBoolErr is template to generate itself for different combination of data type.
func MapIONumberBoolErr() string {
return `
func TestMap<FINPUT_TYPE><FOUTPUT_TYPE>Err(t *testing.T) {
// Test : someLogic
expectedList := []<OUTPUT_TYPE>{true, false}
newList, _ := Map<FINPUT_TYPE><FOUTPUT_TYPE>Err(someLogic<FINPUT_TYPE><FOUTPUT_TYPE>Err, []<INPUT_TYPE>{10, 0})
if newList[0] != expectedList[0] && newList[1] != expectedList[1] {
t.Errorf("Map<FINPUT_TYPE><FOUTPUT_TYPE>Err failed. expected=%v, actual=%v", expectedList, newList)
}
r, _ := Map<FINPUT_TYPE><FOUTPUT_TYPE>Err(nil, nil)
if len(r) > 0 {
t.Errorf("Map<FINPUT_TYPE><FOUTPUT_TYPE>Err failed")
}
r, _ = Map<FINPUT_TYPE><FOUTPUT_TYPE>Err(nil, []<INPUT_TYPE>{})
if len(r) > 0 {
t.Errorf("Map<FINPUT_TYPE><FOUTPUT_TYPE>Err failed")
}
_, err := Map<FINPUT_TYPE><FOUTPUT_TYPE>Err(someLogic<FINPUT_TYPE><FOUTPUT_TYPE>Err, []<INPUT_TYPE>{10, 3})
if err == nil {
t.Errorf("Map<FINPUT_TYPE><FOUTPUT_TYPE>Err failed")
}
reflect.TypeOf("Nandeshwar") // Leaving it here to make use of import reflect
}
`
}
// MapIOStrBoolErr is template to generate itself for different combination of data type.
func MapIOStrBoolErr() string {
return `
func TestMap<FINPUT_TYPE><FOUTPUT_TYPE>Err(t *testing.T) {
// Test : someLogic
expectedList := []<OUTPUT_TYPE>{true, false}
newList, _ := Map<FINPUT_TYPE><FOUTPUT_TYPE>Err(someLogic<FINPUT_TYPE><FOUTPUT_TYPE>Err, []<INPUT_TYPE>{"10", "0"})
if newList[0] != expectedList[0] && newList[1] != expectedList[1] {
t.Errorf("Map<FINPUT_TYPE><FOUTPUT_TYPE>Err failed. expected=%v, actual=%v", expectedList, newList)
}
r, _ := Map<FINPUT_TYPE><FOUTPUT_TYPE>Err(nil, nil)
if len(r) > 0 {
t.Errorf("Map<FINPUT_TYPE><FOUTPUT_TYPE> failed")
}
r, _ = Map<FINPUT_TYPE><FOUTPUT_TYPE>Err(nil, []<INPUT_TYPE>{})
if len(r) > 0 {
t.Errorf("Map<FINPUT_TYPE><FOUTPUT_TYPE>Err failed")
}
_, err := Map<FINPUT_TYPE><FOUTPUT_TYPE>Err(someLogic<FINPUT_TYPE><FOUTPUT_TYPE>Err, []<INPUT_TYPE>{"10", "3"})
if err == nil {
t.Errorf("Map<FINPUT_TYPE><FOUTPUT_TYPE>Err failed")
}
reflect.TypeOf("Nandeshwar") // Leaving it here to make use of import reflect
}
`
}
// MapIOBoolNumberErr is template to generate itself for different combination of data type.
func MapIOBoolNumberErr() string {
return `
func TestMap<FINPUT_TYPE><FOUTPUT_TYPE>Err(t *testing.T) {
// Test : someLogic
expectedList := []<OUTPUT_TYPE>{10, 0}
newList, _ := Map<FINPUT_TYPE><FOUTPUT_TYPE>Err(someLogic<FINPUT_TYPE><FOUTPUT_TYPE>Err, []<INPUT_TYPE>{true, true})
if newList[0] != expectedList[0] && newList[1] != expectedList[1] {
t.Errorf("Map<FINPUT_TYPE><FOUTPUT_TYPE>Err failed. expected=%v, actual=%v", expectedList, newList)
}
r, _ := Map<FINPUT_TYPE><FOUTPUT_TYPE>Err(nil, nil)
if len(r) > 0 {
t.Errorf("Map<FINPUT_TYPE><FOUTPUT_TYPE> failed")
}
r, _ = Map<FINPUT_TYPE><FOUTPUT_TYPE>Err(nil, []<INPUT_TYPE>{})
if len(r) > 0 {
t.Errorf("Map<FINPUT_TYPE><FOUTPUT_TYPE>Err failed")
}
_, err := Map<FINPUT_TYPE><FOUTPUT_TYPE>Err(someLogic<FINPUT_TYPE><FOUTPUT_TYPE>Err, []<INPUT_TYPE>{true, false})
if err == nil {
t.Errorf("Map<FINPUT_TYPE><FOUTPUT_TYPE>Err failed")
}
reflect.TypeOf("Nandeshwar") // Leaving it here to make use of import reflect
}
`
}
// MapIOBoolStrErr is template to generate itself for different combination of data type.
func MapIOBoolStrErr() string {
return `
func TestMap<FINPUT_TYPE><FOUTPUT_TYPE>Err(t *testing.T) {
// Test : someLogic
expectedList := []<OUTPUT_TYPE>{"10", "0"}
newList, _ := Map<FINPUT_TYPE><FOUTPUT_TYPE>Err(someLogic<FINPUT_TYPE><FOUTPUT_TYPE>Err, []<INPUT_TYPE>{true, true})
if newList[0] != expectedList[0] && newList[1] != expectedList[1] {
t.Errorf("Map<FINPUT_TYPE><FOUTPUT_TYPE>Err failed. expected=%v, actual=%v", expectedList, newList)
}
r, _ := Map<FINPUT_TYPE><FOUTPUT_TYPE>Err(nil, nil)
if len(r) > 0 {
t.Errorf("Map<FINPUT_TYPE><FOUTPUT_TYPE>Err failed")
}
r, _ = Map<FINPUT_TYPE><FOUTPUT_TYPE>Err(nil, []<INPUT_TYPE>{})
if len(r) > 0 {
t.Errorf("Map<FINPUT_TYPE><FOUTPUT_TYPE>Err failed")
}
_, err := Map<FINPUT_TYPE><FOUTPUT_TYPE>Err(someLogic<FINPUT_TYPE><FOUTPUT_TYPE>Err, []<INPUT_TYPE>{true, false})
if err == nil {
t.Errorf("Map<FINPUT_TYPE><FOUTPUT_TYPE>Err failed")
}
reflect.TypeOf("Nandeshwar") // Leaving it here to make use of import reflect
}
`
}
// ReplaceActivityMapIOErr replaces ...
func ReplaceActivityMapIOErr(code string) string {
s1 := `import (
_ "errors"
"reflect"
"testing"
)
func TestMapIntInt64Err(t *testing.T) {`
s2 := `import (
"errors"
"reflect"
"testing"
)
func TestMapIntInt64Err(t *testing.T) {`
code = strings.Replace(code, s1, s2, -1)
return code
} | internal/template/basic/mapiotest.go | 0.587352 | 0.495117 | mapiotest.go | starcoder |
package year2021
import (
"fmt"
"strings"
"github.com/lanphiergm/adventofcodego/internal/utils"
)
// Passage Pathing Part 1 computes the number of paths through the cave system if
// small caves can be visited only once
func PassagePathingPart1(filename string) interface{} {
dsts := parsePaths(filename)
paths := findPathsTo(dsts, []string{",end"}, "end")
return len(paths)
}
// Passage Pathing Part 2 computes the number of paths through the cave system if
// a single small cave can be visited twice
func PassagePathingPart2(filename string) interface{} {
dsts := parsePaths(filename)
paths := findPathsToWithDoubleSmall(dsts, []string{",end"}, "end", false)
return len(paths)
}
// Depth-first search starting at the end and working backwards to the start
func findPathsTo(dsts map[string][]string, paths []string, dst string) []string {
srcs := dsts[dst]
newPaths := make([]string, 0)
for _, src := range srcs {
for _, path := range paths {
if src == "start" {
newPaths = append(newPaths, fmt.Sprintf("start%v", path))
} else if strings.ToUpper(src) == src || !strings.Contains(path, fmt.Sprintf(",%v,", src)) {
newPaths = append(newPaths, findPathsTo(dsts, []string{fmt.Sprintf(",%v%v", src, path)}, src)...)
}
}
}
return newPaths
}
// Depth-first search starting at the end and working backwards to the start
func findPathsToWithDoubleSmall(dsts map[string][]string, paths []string, dst string, hasDoubleSmall bool) []string {
srcs := dsts[dst]
newPaths := make([]string, 0)
for _, src := range srcs {
for _, path := range paths {
if src == "start" {
newPaths = append(newPaths, fmt.Sprintf("start%v", path))
} else if strings.ToUpper(src) == src {
newPaths = append(newPaths, findPathsToWithDoubleSmall(dsts, []string{fmt.Sprintf(",%v%v", src, path)}, src, hasDoubleSmall)...)
} else if !strings.Contains(path, fmt.Sprintf(",%v,", src)) {
newPaths = append(newPaths, findPathsToWithDoubleSmall(dsts, []string{fmt.Sprintf(",%v%v", src, path)}, src, hasDoubleSmall)...)
} else if !hasDoubleSmall {
newPaths = append(newPaths, findPathsToWithDoubleSmall(dsts, []string{fmt.Sprintf(",%v%v", src, path)}, src, true)...)
}
}
}
return newPaths
}
func parsePaths(filename string) map[string][]string {
data := utils.ReadStrings(filename)
dsts := make(map[string][]string)
for _, line := range data {
pair := strings.Split(line, "-")
// first direction
srcs := dsts[pair[1]]
if srcs == nil {
srcs = make([]string, 0)
}
if pair[0] != "end" && pair[1] != "start" {
srcs = append(srcs, pair[0])
dsts[pair[1]] = srcs
}
// second direction
srcs = dsts[pair[0]]
if srcs == nil {
srcs = make([]string, 0)
}
if pair[1] != "end" && pair[0] != "start" {
srcs = append(srcs, pair[1])
dsts[pair[0]] = srcs
}
}
return dsts
} | internal/puzzles/year2021/day_12_passage_pathing.go | 0.659076 | 0.425546 | day_12_passage_pathing.go | starcoder |
package physics2d
import (
"math"
"github.com/puoklam/physics2d/collision"
"github.com/puoklam/physics2d/force"
"github.com/puoklam/physics2d/math/vector"
"github.com/puoklam/physics2d/shape"
)
type World struct {
registry *force.Registry
bodies []*shape.Body
dt float64
collisions []collision.Collision
}
func NewWorld(dt float64) *World {
return &World{
force.NewRegistry(),
make([]*shape.Body, 0),
dt,
make([]collision.Collision, 0),
}
}
func (w *World) FixedUpdate() {
// update force
w.registry.Update(w.dt)
// find collisions
w.collisions = nil
for i, b1 := range w.bodies {
for _, b2 := range w.bodies[i+1:] {
if b1.Mass() == shape.InfMass && b2.Mass() == shape.InfMass {
continue
}
if c1, c2 := b1.Collider, b2.Collider; c1 != nil && c2 != nil {
if m, ok := collision.FindCollision(c1, c2); ok {
w.collisions = append(w.collisions, collision.Collision{
Body1: b1,
Body2: b2,
Manifold: m,
})
}
}
}
}
// resolve collisions (impulse resolution)
for k := 0; k < 8; k++ {
for _, c := range w.collisions {
for j := 0; j < len(c.Manifold.Contacts); j++ {
applyImpulse(c.Body1, c.Body2, c.Manifold)
}
}
}
// update velocity
for _, body := range w.bodies {
body.Update(w.dt)
}
}
func (w *World) Update(dt float64) {
w.FixedUpdate()
}
func (w *World) AddBody(body *shape.Body) {
w.bodies = append(w.bodies, body)
}
type Gravity struct {
a *vector.Vector2D
}
func (g Gravity) Update(body *shape.Body, dt float64) {
body.AddForce(vector.Mul(g.a, body.Mass()))
}
func (g Gravity) Zero() {
}
func NewGravity(a *vector.Vector2D) Gravity {
return Gravity{vector.Copy(a)}
}
func applyImpulse(b1, b2 *shape.Body, m *collision.Manifold) {
massInv1, massInv2 := b1.MassInv(), b2.MassInv()
massInvSum := massInv1 + massInv2
if massInvSum == 0 {
return
}
relVelo := vector.Sub(b2.LinVelo, b1.LinVelo)
relNormal := vector.Copy(m.Normal)
dp := vector.Dot(relVelo, relNormal)
// TODO: fps small -> dt too large -> b1 and b2 overlap too much
if dp > 0 {
return
}
e := math.Min(b1.Cor, b2.Cor)
j := -(1 + e) * dp / massInvSum
if len(m.Contacts) > 0 && j != 0 {
j /= float64(len(m.Contacts))
}
impulse := vector.Mul(vector.Copy(relNormal), j)
b1.LinVelo.Add(vector.Mul(vector.Copy(impulse), -massInv1))
b2.LinVelo.Add(vector.Mul(vector.Copy(impulse), massInv2))
} | world.go | 0.620047 | 0.488649 | world.go | starcoder |
package assert
import (
"fmt"
"reflect"
"runtime"
"testing"
)
// Version returns package version
func Version() string {
return "0.11.0"
}
// Author returns package author
func Author() string {
return "[<NAME>](https://www.likexian.com/)"
}
// License returns package license
func License() string {
return "Licensed under the Apache License 2.0"
}
// Equal assert test value to be equal
func Equal(t *testing.T, got, exp interface{}, args ...interface{}) {
equal(t, got, exp, 1, args...)
}
// NotEqual assert test value to be not equal
func NotEqual(t *testing.T, got, exp interface{}, args ...interface{}) {
notEqual(t, got, exp, 1, args...)
}
// Nil assert test value to be nil
func Nil(t *testing.T, got interface{}, args ...interface{}) {
equal(t, got, nil, 1, args...)
}
// NotNil assert test value to be not nil
func NotNil(t *testing.T, got interface{}, args ...interface{}) {
notEqual(t, got, nil, 1, args...)
}
// True assert test value to be true
func True(t *testing.T, got interface{}, args ...interface{}) {
equal(t, got, true, 1, args...)
}
// False assert test value to be false
func False(t *testing.T, got interface{}, args ...interface{}) {
notEqual(t, got, true, 1, args...)
}
// Zero assert test value to be zero value
func Zero(t *testing.T, got interface{}, args ...interface{}) {
equal(t, IsZero(got), true, 1, args...)
}
// NotZero assert test value to be not zero value
func NotZero(t *testing.T, got interface{}, args ...interface{}) {
notEqual(t, IsZero(got), true, 1, args...)
}
// Len assert length of test vaue to be exp
func Len(t *testing.T, got interface{}, exp int, args ...interface{}) {
equal(t, Length(got), exp, 1, args...)
}
// NotLen assert length of test vaue to be not exp
func NotLen(t *testing.T, got interface{}, exp int, args ...interface{}) {
notEqual(t, Length(got), exp, 1, args...)
}
// Contains assert test value to be contains
func Contains(t *testing.T, got, exp interface{}, args ...interface{}) {
equal(t, IsContains(got, exp), true, 1, args...)
}
// NotContains assert test value to be contains
func NotContains(t *testing.T, got, exp interface{}, args ...interface{}) {
notEqual(t, IsContains(got, exp), true, 1, args...)
}
// Match assert test value match exp pattern
func Match(t *testing.T, got, exp interface{}, args ...interface{}) {
equal(t, IsMatch(got, exp), true, 1, args...)
}
// NotMatch assert test value not match exp pattern
func NotMatch(t *testing.T, got, exp interface{}, args ...interface{}) {
notEqual(t, IsMatch(got, exp), true, 1, args...)
}
// Lt assert test value less than exp
func Lt(t *testing.T, got, exp interface{}, args ...interface{}) {
equal(t, IsLt(got, exp), true, 1, args...)
}
// Le assert test value less than exp or equal
func Le(t *testing.T, got, exp interface{}, args ...interface{}) {
equal(t, IsLe(got, exp), true, 1, args...)
}
// Gt assert test value greater than exp
func Gt(t *testing.T, got, exp interface{}, args ...interface{}) {
equal(t, IsGt(got, exp), true, 1, args...)
}
// Ge assert test value greater than exp or equal
func Ge(t *testing.T, got, exp interface{}, args ...interface{}) {
equal(t, IsGe(got, exp), true, 1, args...)
}
// Panic assert testing to be panic
func Panic(t *testing.T, fn func(), args ...interface{}) {
defer func() {
ff := func() {
t.Error("! -", "assert expected to be panic")
if len(args) > 0 {
t.Error("! -", fmt.Sprint(args...))
}
}
ok := recover() != nil
assert(t, ok, ff, 2)
}()
fn()
}
// NotPanic assert testing to be panic
func NotPanic(t *testing.T, fn func(), args ...interface{}) {
defer func() {
ff := func() {
t.Error("! -", "assert expected to be not panic")
if len(args) > 0 {
t.Error("! -", fmt.Sprint(args...))
}
}
ok := recover() == nil
assert(t, ok, ff, 3)
}()
fn()
}
func equal(t *testing.T, got, exp interface{}, step int, args ...interface{}) {
fn := func() {
switch got.(type) {
case error:
t.Errorf("! unexpected error: \"%s\"", got)
default:
t.Errorf("! expected %#v, but got %#v", exp, got)
}
if len(args) > 0 {
t.Error("! -", fmt.Sprint(args...))
}
}
ok := reflect.DeepEqual(exp, got)
assert(t, ok, fn, step+1)
}
func notEqual(t *testing.T, got, exp interface{}, step int, args ...interface{}) {
fn := func() {
t.Errorf("! unexpected: %#v", got)
if len(args) > 0 {
t.Error("! -", fmt.Sprint(args...))
}
}
ok := !reflect.DeepEqual(exp, got)
assert(t, ok, fn, step+1)
}
func assert(t *testing.T, pass bool, fn func(), step int) {
if !pass {
_, file, line, ok := runtime.Caller(step + 1)
if ok {
t.Errorf("%s:%d", file, line)
}
fn()
t.FailNow()
}
} | vendor/github.com/likexian/gokit/assert/assert.go | 0.703753 | 0.609844 | assert.go | starcoder |
package graph
// Visit is a function type that is used by a BreadthFirst or DepthFirst to allow side-effects
// on visiting new nodes in a graph traversal.
type Visit func(u, v Node)
// BreadthFirst is a type that can perform a breadth-first search on a graph.
type BreadthFirst struct {
q *queue
visits []bool
}
// NewBreadthFirst creates a new BreadthFirst searcher.
func NewBreadthFirst() *BreadthFirst {
return &BreadthFirst{q: &queue{}}
}
// Search searches a graph starting from node s until the NodeFilter function nf returns a value of
// true, traversing edges in the graph that allow the Edgefilter function ef to return true. On success
// the terminating node, t is returned. If vo is not nil, it is called with the start and end nodes of an
// edge when the end node has not already been visited.
func (b *BreadthFirst) Search(s Node, ef EdgeFilter, nf NodeFilter, vo Visit) Node {
b.q.Enqueue(s)
b.visits = mark(s, b.visits)
for b.q.Len() > 0 {
t, err := b.q.Dequeue()
if err != nil {
panic(err)
}
if nf != nil && nf(t) {
return t
}
for _, n := range t.Neighbors(ef) {
if !b.Visited(n) {
if vo != nil {
vo(t, n)
}
b.visits = mark(n, b.visits)
b.q.Enqueue(n)
}
}
}
return nil
}
// Visited returns whether the node n has been visited by the searcher.
func (b *BreadthFirst) Visited(n Node) bool {
id := n.ID()
if id < 0 || id >= len(b.visits) {
return false
}
return b.visits[id]
}
// Reset clears the search queue and visited list.
func (b *BreadthFirst) Reset() {
b.q.Clear()
b.visits = b.visits[:0]
}
// DepthFirst is a type that can perform a depth-first search on a graph.
type DepthFirst struct {
s *stack
visits []bool
}
// NewDepthFirst creates a new DepthFirst searcher.
func NewDepthFirst() *DepthFirst {
return &DepthFirst{s: &stack{}}
}
// Search searches a graph starting from node s until the NodeFilter function nf returns a value of
// true, traversing edges in the graph that allow the Edgefilter function ef to return true. On success
// the terminating node, t is returned. If vo is not nil, it is called with the start and end nodes of an
// edge when the end node has not already been visited.
func (d *DepthFirst) Search(s Node, ef EdgeFilter, nf NodeFilter, vo Visit) Node {
d.s.Push(s)
d.visits = mark(s, d.visits)
for d.s.Len() > 0 {
t, err := d.s.Pop()
if err != nil {
panic(err)
}
if nf != nil && nf(t) {
return t
}
for _, n := range t.Neighbors(ef) {
if !d.Visited(n) {
if vo != nil {
vo(t, n)
}
d.visits = mark(n, d.visits)
d.s.Push(n)
}
}
}
return nil
}
// Visited returns whether the node n has been visited by the searcher.
func (d *DepthFirst) Visited(n Node) bool {
id := n.ID()
if id < 0 || id >= len(d.visits) {
return false
}
return d.visits[id]
}
// Reset clears the search stack and visited list.
func (d *DepthFirst) Reset() {
d.s.Clear()
d.visits = d.visits[:0]
}
func mark(n Node, v []bool) []bool {
id := n.ID()
switch {
case id == len(v):
v = append(v, true)
case id > len(v):
t := make([]bool, id+1)
copy(t, v)
v = t
v[id] = true
default:
v[id] = true
}
return v
} | traverse.go | 0.768038 | 0.566798 | traverse.go | starcoder |
package spec
import (
"fmt"
"sort"
"strconv"
"strings"
"github.com/diamondburned/arikawa/v3/api"
"github.com/diamondburned/arikawa/v3/discord"
)
func (s Spec) Search(query string) []*Node {
query = strings.ToLower(query)
fields := strings.Fields(query)
switch len(fields) {
case 0:
return nil
}
results := map[*Node]int{}
for _, f := range fields {
for _, node := range s.Keywords[f] {
// exact match
if strings.ToLower(node.Heading) == query {
return []*Node{node}
}
results[node]++
}
}
keys := make([]*Node, 0, len(results))
for n, num := range results {
if num == len(fields) {
keys = append(keys, n)
}
}
sort.Slice(keys, func(i, j int) bool {
n1 := keys[i]
n2 := keys[j]
var basic bool
if n1.Level != n2.Level {
// show lower matches first - more specific
basic = n2.Level < n1.Level
} else {
basic = n1.Heading < n2.Heading
}
title1, title2 := strings.ToLower(n1.Heading), strings.ToLower(n2.Heading)
c1, c2 := strings.Contains(title1, query), strings.Contains(title2, query)
switch {
case c1 && c2:
return basic
case c1:
return true
case c2:
return false
}
var desc1, desc2 strings.Builder
for _, d := range n1.Content {
desc1.WriteString(strings.ToLower(d.Markdown()))
}
for _, d := range n2.Content {
desc2.WriteString(strings.ToLower(d.Markdown()))
}
c1, c2 = strings.Contains(desc1.String(), query), strings.Contains(desc2.String(), query)
switch {
case c1 && c2:
return basic
case c1:
return true
case c2:
return false
}
return basic
})
return keys
}
func (n Node) Match() string {
return fmt.Sprintf("> [%s](%s#%s)\n", n.Heading, page, strings.ReplaceAll(n.Heading, " ", "_"))
}
func (n Node) Render(limit int) (string, bool) {
switch len(n.Content) {
case 0:
return "", false
}
var more bool
var b strings.Builder
for _, c := range n.Content {
if b.Len() > limit {
more = true
break
}
b.WriteString(c.Markdown())
b.WriteRune('\n')
}
for _, node := range n.Nodes {
if b.Len() > limit {
more = true
break
}
md, _ := node.Render(limit - b.Len())
b.WriteString(md)
b.WriteRune('\n')
}
if more {
b.WriteString("*More documentation omitted*")
}
return b.String(), more
}
func (h Heading) Markdown() string {
var text string
switch h.Level {
case 2:
text = "__**" + h.Text + "**__"
case 3:
text = "__" + h.Text + "__"
case 4:
text = h.Text
}
return fmt.Sprintf("> [%s](%s#%s)\n", text, page, strings.ReplaceAll(h.Text, " ", "_"))
}
func (p Paragraph) Markdown() string {
switch len(p) {
case 0:
return ""
case 1:
return p[0].Markdown()
}
var b strings.Builder
for _, part := range p {
b.WriteString(part.Markdown())
}
return strings.TrimSpace(b.String()) + "\n"
}
func (t Text) Markdown() string {
return string(t)
}
func (t Link) Markdown() string {
return fmt.Sprintf("[%s](%s)", string(t.Text), t.Location)
}
const bullet = " • "
func (l List) prefix(n int) string {
if l.Ordered {
return strconv.Itoa(n) + " . "
}
return bullet
}
func (l List) Markdown() string {
switch len(l.Items) {
case 0:
return ""
case 1:
return l.prefix(1) + l.Items[0].Markdown()
}
var b strings.Builder
b.WriteString(l.prefix(1))
b.WriteString(l.Items[0].Markdown())
i := 2
for _, n := range l.Items[1:] {
b.WriteRune('\n')
b.WriteString(l.prefix(i))
b.WriteString(n.Markdown())
i++
}
return b.String()
}
func (c Code) Markdown() string {
code := string(c)
if code == "``" {
code = " `` "
}
return "`" + code + "`"
}
func (i Italic) Markdown() string {
return "*" + string(i) + "*"
}
func (p Pre) Markdown() string {
return "```\n" + string(p) + "\n```\n"
}
var (
Cache Spec
TOC *api.InteractionResponseData
Subcomponents = map[string][]discord.SelectOption{}
)
var (
tocOptions []discord.SelectOption
GoBack = discord.SelectOption{
Label: "Go Back",
Value: "back",
Emoji: &discord.ComponentEmoji{Name: "↩️"},
}
)
func init() {
var err error
Cache, err = QuerySpec()
if err != nil {
panic(err)
}
for i, node := range Cache.Nodes {
prefix := strconv.Itoa(i+1) + ". "
tocOptions = append(tocOptions, discord.SelectOption{
Label: prefix + node.Heading,
Value: node.Heading,
})
Subcomponents[node.Heading] = append(Subcomponents[node.Heading], GoBack)
for i, sub := range node.Nodes {
prefix := strconv.Itoa(i+1) + ". "
Subcomponents[node.Heading] = append(Subcomponents[node.Heading], discord.SelectOption{
Label: prefix + sub.Heading,
Value: sub.Heading,
})
}
}
TOC = &api.InteractionResponseData{
Flags: api.EphemeralResponse,
Embeds: &[]discord.Embed{{
Title: "Spec - Table of Contents",
Description: `Use the component below to select a subheading.
Search for a full heading to view full heading contents.
**Example**:
/spec query:introduction
/spec query:method sets
/spec query:packages`,
Color: 0x00ADD8,
}},
Components: discord.ComponentsPtr(
&discord.SelectComponent{
CustomID: "spec.toc",
Placeholder: "View Headings",
Options: tocOptions,
},
),
}
}
func NodesSelect(nodes []*Node) *discord.ContainerComponents {
var options []discord.SelectOption
options = append(options, GoBack)
for i, node := range nodes {
prefix := strconv.Itoa(i+1) + ". "
options = append(options, discord.SelectOption{
Label: prefix + node.Heading,
Value: node.Heading,
})
}
return discord.ComponentsPtr(
&discord.SelectComponent{
Placeholder: "Select",
CustomID: "spec.toc",
Options: options,
},
)
} | spec/util.go | 0.557123 | 0.42322 | util.go | starcoder |
package mat
import (
"github.com/chewxy/math32"
"github.com/foxis/EasyRobot/pkg/core/math/vec"
)
type Matrix4x3 [4][3]float32
func New4x3(arr ...float32) Matrix4x3 {
m := Matrix4x3{}
if arr != nil {
for i := range m {
copy(m[i][:], arr[i*3 : i*3+3][:])
}
}
return m
}
// Returns a flat representation of this matrix.
func (m *Matrix4x3) Flat(v vec.Vector) vec.Vector {
N := len(m[0])
for i, row := range m {
copy(v[i*N:i*N+N], row[:])
}
return v
}
// Returns a Matrix view of this matrix.
// The view actually contains slices of original matrix rows.
// This way original matrix can be modified.
func (m *Matrix4x3) Matrix() Matrix {
m1 := make(Matrix, len(m))
for i := range m {
m1[i] = m[i][:]
}
return m1
}
// Fills destination matrix with a rotation around X axis
// Matrix size must be at least 3x3
func (m *Matrix4x3) RotationX(a float32) *Matrix4x3 {
c := math32.Cos(a)
s := math32.Sin(a)
return m.SetSubmatrixRaw(0, 0, 3, 3,
1, 0, 0,
0, c, -s,
0, s, c,
)
}
// Fills destination matrix with a rotation around Y axis
// Matrix size must be at least 3x3
func (m *Matrix4x3) RotationY(a float32) *Matrix4x3 {
c := math32.Cos(a)
s := math32.Sin(a)
return m.SetSubmatrixRaw(0, 0, 3, 3,
c, 0, s,
0, 1, 0,
-s, 0, c,
)
}
// Fills destination matrix with a rotation around Z axis
// Matrix size must be at least 3x3
func (m *Matrix4x3) RotationZ(a float32) *Matrix4x3 {
c := math32.Cos(a)
s := math32.Sin(a)
return m.SetSubmatrixRaw(0, 0, 3, 3,
c, -s, 0,
s, c, 0,
0, 0, 1,
)
}
// Build orientation matrix from quaternion
// Matrix size must be at least 3x3
// Quaternion axis must be unit vector
func (m *Matrix4x3) Orientation(q vec.Quaternion) *Matrix4x3 {
theta := q.Theta() / 2
qr := math32.Cos(theta)
s := math32.Sin(theta)
qi := q[0] * s
qj := q[1] * s
qk := q[2] * s
// calculate quaternion rotation matrix
qjqj := qj * qj
qiqi := qi * qi
qkqk := qk * qk
qiqj := qi * qj
qjqr := qj * qr
qiqk := qi * qk
qiqr := qi * qr
qkqr := qk * qr
qjqk := qj * qk
return m.SetSubmatrixRaw(0, 0, 3, 3,
1.0-2.0*(qjqj+qkqk),
2.0*(qiqj+qkqr),
2.0*(qiqk+qjqr),
2.0*(qiqj+qkqr),
1.0-2.0*(qiqi+qkqk),
2.0*(qjqk+qiqr),
2.0*(qiqk+qjqr),
2.0*(qjqk+qiqr),
1.0-2.0*(qiqi+qjqj),
)
}
// Returns a slice to the row.
func (m *Matrix4x3) Row(row int) vec.Vector {
return m[row][:]
}
// Returns a copy of the matrix column.
func (m *Matrix4x3) Col(col int, v vec.Vector) vec.Vector {
for i, row := range m {
v[i] = row[col]
}
return v
}
func (m *Matrix4x3) SetRow(row int, v vec.Vector) *Matrix4x3 {
copy(m[row][:], v[:])
return m
}
func (m *Matrix4x3) SetCol(col int, v vec.Vector) *Matrix4x3 {
for i, v := range v {
m[i][col] = v
}
return m
}
func (m *Matrix4x3) Submatrix(row, col int, m1 Matrix) Matrix {
cols := len(m1[0])
for i, m1row := range m1 {
copy(m1row, m[row+i][col : cols+col][:])
}
return m1
}
func (m *Matrix4x3) SetSubmatrix(row, col int, m1 Matrix) *Matrix4x3 {
for i := range m[row : row+len(m1)] {
copy(m[row+i][col : col+len(m1[i])][:], m1[i][:])
}
return m
}
func (m *Matrix4x3) SetSubmatrixRaw(row, col, rows1, cols1 int, m1 ...float32) *Matrix4x3 {
for i := 0; i < rows1; i++ {
copy(m[row+i][col : col+cols1][:], m1[i*cols1:i*cols1+cols1])
}
return m
}
func (m *Matrix4x3) Clone() *Matrix4x3 {
m1 := &Matrix4x3{}
for i, row := range m {
copy(m1[i][:], row[:])
}
return m1
}
// Transposes matrix m1 and stores the result in the destination matrix
// destination matrix must be of appropriate size.
// NOTE: Does not support in place transpose
func (m *Matrix4x3) Transpose(m1 Matrix3x4) *Matrix4x3 {
for i, row := range m1 {
for j, val := range row {
m[j][i] = val
}
}
return m
}
func (m *Matrix4x3) Add(m1 Matrix4x3) *Matrix4x3 {
for i := range m {
vec.Vector(m[i][:]).Add(m1[i][:])
}
return m
}
func (m *Matrix4x3) Sub(m1 Matrix4x3) *Matrix4x3 {
for i := range m {
vec.Vector(m[i][:]).Sub(m1[i][:])
}
return m
}
func (m *Matrix4x3) MulC(c float32) *Matrix4x3 {
for i := range m {
vec.Vector(m[i][:]).MulC(c)
}
return m
}
func (m *Matrix4x3) DivC(c float32) *Matrix4x3 {
for i := range m {
vec.Vector(m[i][:]).DivC(c)
}
return m
}
// Destination matrix must be properly sized.
// given that a is MxN and b is NxK
// then destinatiom matrix must be MxK
func (m *Matrix4x3) Mul(a Matrix, b Matrix3x4) *Matrix4x3 {
for i, row := range a {
mrow := m[i][:]
for j := range mrow {
var sum float32
for k, brow := range b {
sum += row[k] * brow[j]
}
mrow[j] = sum
}
}
return m
}
// Vector must have a size equal to number of cols.
// Destination vector must have a size equal to number of rows.
func (m *Matrix4x3) MulVec(v vec.Vector3D, dst vec.Vector) vec.Vector {
for i, row := range m {
var sum float32
for j, val := range row {
sum += v[j] * val
}
dst[i] = sum
}
return dst
}
// Vector must have a size equal to number of rows.
// Destination vector must have a size equal to number of cols.
func (m *Matrix4x3) MulVecT(v vec.Vector4D, dst vec.Vector) vec.Vector {
for i := range m[0] {
var sum float32
for j, val := range m {
sum += v[j] * val[i]
}
dst[i] = sum
}
return dst
}
/// https://math.stackexchange.com/questions/893984/conversion-of-rotation-matrix-to-quaternion
/// Must be at least 3x3 matrix
func (m *Matrix4x3) Quaternion() (q *vec.Quaternion) {
var t float32
if m[2][2] < 0 {
if m[0][0] > m[1][1] {
t = 1 + m[0][0] - m[1][1] - m[2][2]
q = &vec.Quaternion{t, m[0][1] + m[1][0], m[2][0] + m[0][2], m[1][2] - m[2][1]}
} else {
t = 1 - m[0][0] + m[1][1] - m[2][2]
q = &vec.Quaternion{m[0][1] + m[1][0], t, m[1][2] + m[2][1], m[2][0] - m[0][2]}
}
} else {
if m[0][0] < -m[1][1] {
t = 1 - m[0][0] - m[1][1] + m[2][2]
q = &vec.Quaternion{m[2][0] + m[0][2], m[1][2] + m[2][1], t, m[0][1] - m[1][0]}
} else {
t = 1 + m[0][0] + m[1][1] + m[2][2]
q = &vec.Quaternion{m[1][2] - m[2][1], m[2][0] - m[0][2], m[0][1] - m[1][0], t}
}
}
q.Vector().MulC(0.5 / math32.Sqrt(t))
return
} | pkg/core/math/mat/mat4x3.go | 0.840815 | 0.580411 | mat4x3.go | starcoder |
package iso20022
// Net position of a segregated holding, in a single security, within the overall position held in a securities account at a specified place of safekeeping.
type AggregateBalancePerSafekeepingPlace12 struct {
// Place where the securities are safe-kept, physically or notionally. This place can be, for example, a local custodian, a Central Securities Depository (CSD) or an International Central Securities Depository (ICSD).
SafekeepingPlace *SafekeepingPlaceFormat3Choice `xml:"SfkpgPlc"`
// Market(s) on which the security is listed.
PlaceOfListing *MarketIdentification5 `xml:"PlcOfListg,omitempty"`
// Total quantity of financial instruments of the balance.
AggregateBalance *Balance1 `xml:"AggtBal"`
// Price of the financial instrument in one or more currencies.
PriceDetails []*PriceInformation5 `xml:"PricDtls"`
// Information needed to process a currency exchange or conversion.
ForeignExchangeDetails []*ForeignExchangeTerms14 `xml:"FXDtls,omitempty"`
// Specifies the number of days used for calculating the accrued interest amount.
DaysAccrued *Number `xml:"DaysAcrd,omitempty"`
// Valuation amounts provided in the base currency of the account.
AccountBaseCurrencyAmounts *BalanceAmounts1 `xml:"AcctBaseCcyAmts"`
// Valuation amounts provided in the currency of the financial instrument.
InstrumentCurrencyAmounts *BalanceAmounts1 `xml:"InstrmCcyAmts,omitempty"`
// Valuation amounts provided in another currency than the base currency of the account.
AlternateReportingCurrencyAmounts *BalanceAmounts1 `xml:"AltrnRptgCcyAmts,omitempty"`
// Breakdown of the aggregate quantity reported into significant lots, for example, tax lots.
QuantityBreakdown []*QuantityBreakdown4 `xml:"QtyBrkdwn,omitempty"`
// Breakdown of the aggregate balance per meaningful sub-balances and availability.
BalanceBreakdown []*SubBalanceInformation6 `xml:"BalBrkdwn,omitempty"`
// Provides additional instrument sub-balance information on all or parts of the reported financial instrument (unregistered, tax exempt, etc.).
AdditionalBalanceBreakdown []*AdditionalBalanceInformation6 `xml:"AddtlBalBrkdwn,omitempty"`
// Provides additional information on the holding.
HoldingAdditionalDetails *Max350Text `xml:"HldgAddtlDtls,omitempty"`
}
func (a *AggregateBalancePerSafekeepingPlace12) AddSafekeepingPlace() *SafekeepingPlaceFormat3Choice {
a.SafekeepingPlace = new(SafekeepingPlaceFormat3Choice)
return a.SafekeepingPlace
}
func (a *AggregateBalancePerSafekeepingPlace12) AddPlaceOfListing() *MarketIdentification5 {
a.PlaceOfListing = new(MarketIdentification5)
return a.PlaceOfListing
}
func (a *AggregateBalancePerSafekeepingPlace12) AddAggregateBalance() *Balance1 {
a.AggregateBalance = new(Balance1)
return a.AggregateBalance
}
func (a *AggregateBalancePerSafekeepingPlace12) AddPriceDetails() *PriceInformation5 {
newValue := new(PriceInformation5)
a.PriceDetails = append(a.PriceDetails, newValue)
return newValue
}
func (a *AggregateBalancePerSafekeepingPlace12) AddForeignExchangeDetails() *ForeignExchangeTerms14 {
newValue := new(ForeignExchangeTerms14)
a.ForeignExchangeDetails = append(a.ForeignExchangeDetails, newValue)
return newValue
}
func (a *AggregateBalancePerSafekeepingPlace12) SetDaysAccrued(value string) {
a.DaysAccrued = (*Number)(&value)
}
func (a *AggregateBalancePerSafekeepingPlace12) AddAccountBaseCurrencyAmounts() *BalanceAmounts1 {
a.AccountBaseCurrencyAmounts = new(BalanceAmounts1)
return a.AccountBaseCurrencyAmounts
}
func (a *AggregateBalancePerSafekeepingPlace12) AddInstrumentCurrencyAmounts() *BalanceAmounts1 {
a.InstrumentCurrencyAmounts = new(BalanceAmounts1)
return a.InstrumentCurrencyAmounts
}
func (a *AggregateBalancePerSafekeepingPlace12) AddAlternateReportingCurrencyAmounts() *BalanceAmounts1 {
a.AlternateReportingCurrencyAmounts = new(BalanceAmounts1)
return a.AlternateReportingCurrencyAmounts
}
func (a *AggregateBalancePerSafekeepingPlace12) AddQuantityBreakdown() *QuantityBreakdown4 {
newValue := new(QuantityBreakdown4)
a.QuantityBreakdown = append(a.QuantityBreakdown, newValue)
return newValue
}
func (a *AggregateBalancePerSafekeepingPlace12) AddBalanceBreakdown() *SubBalanceInformation6 {
newValue := new(SubBalanceInformation6)
a.BalanceBreakdown = append(a.BalanceBreakdown, newValue)
return newValue
}
func (a *AggregateBalancePerSafekeepingPlace12) AddAdditionalBalanceBreakdown() *AdditionalBalanceInformation6 {
newValue := new(AdditionalBalanceInformation6)
a.AdditionalBalanceBreakdown = append(a.AdditionalBalanceBreakdown, newValue)
return newValue
}
func (a *AggregateBalancePerSafekeepingPlace12) SetHoldingAdditionalDetails(value string) {
a.HoldingAdditionalDetails = (*Max350Text)(&value)
} | AggregateBalancePerSafekeepingPlace12.go | 0.871707 | 0.409162 | AggregateBalancePerSafekeepingPlace12.go | starcoder |
package main
type Age int
type Person struct {
name string
age Age
friend *Person
}
func main() {
john := Person{"John", 25, nil}
pJohn := &john
pJohn.age++
//Indiquez true ou false en troisième argument
assert("Q1", john.age == 25, false)
assert("Q1", john.age == 26, true)
assert("Q1", pJohn.age == 25, false)
assert("Q1", pJohn.age == 26, true)
pAgeJ := &(john.age)
bob := Person{"Bob", 26, &john}
pAgeB := &(bob.age)
//Indiquez true ou false en troisième argument
assert("Q2", pAgeJ == pAgeB, false)
//Indiquez true ou false en troisième argument
assert("Q3", *pAgeJ == john.age, true)
assert("Q3", *pAgeJ == bob.age, true)
*pAgeJ = 10
//Indiquez true ou false en troisième argument
assert("Q4", *pAgeJ == john.age, true)
assert("Q4", *pAgeJ == bob.age, false)
john.age = 12
//Indiquez true ou false en troisième argument
assert("Q5", *pAgeJ == john.age, true)
assert("Q5", *pAgeJ == bob.age, false)
john.age = *pAgeB
//Indiquez true ou false en troisième argument
assert("Q6", *pAgeJ == john.age, true)
assert("Q6", *pAgeJ == bob.age, true)
*pAgeB = 18
//Indiquez true ou false en troisième argument
assert("Q7", john.age == 18, false)
assert("Q7", bob.age == 18, true)
bob.friend.age = *pAgeB + 1
//Indiquez true ou false en troisième argument
assert("Q8", john.age == 19, true)
assert("Q8", bob.age == 19, false)
bob.friend = &bob
bob.friend.age = 20
//Indiquez true ou false en troisième argument
assert("Q8", john.age == 20, false)
assert("Q8", bob.age == 20, true)
bob.friend = &bob
pFriend := bob.friend
bob.friend.friend = &john
//Indiquez true ou false en troisième argument
assert("Q9", bob.friend == pFriend, false)
assert("Q9", bob.friend == pJohn, true)
eric := john
//Indiquez true ou false en troisième argument
assert("Q10", eric == john, true)
assert("Q10", &eric == &john, false)
assert("Q10", *&eric == *&john, true)
eric.name = "Eric"
//Indiquez true ou false en troisième argument
assert("Q11", john.name == "Eric", false)
assert("Q11", eric == john, false)
assert("Q11", &eric == &john, false)
assert("Q11", *&eric == *&john, false)
}
func assert(message string, value, expected bool) {
if value != expected {
panic(message)
}
} | go100/14-exercices/correction/main.go | 0.514644 | 0.660487 | main.go | starcoder |
package timef
import (
"strings"
"time"
)
// ToFormat convert date to desired format
func ToFormat(value, layout, format string) (string, error) {
var (
res string
trd time.Time
err error
)
if layout == "" {
return value, nil
}
if trd, err = time.Parse(layout, value); err != nil {
return value, err
}
if format != "" {
res = trd.Format(format)
} else {
res = trd.String()
}
return res, err
}
// ToYYYYMMDD convert to YYYY-MM-DD or YYYY/MM/DD or YYYY.MM.DD or YYYYMMDD
func ToYYYYMMDD(day, layout string, separator rune) (string, error) {
switch separator {
case 45: // "-"
return ToFormat(day, layout, Format[FormatDayLongYearAtBegin1])
case 47: // "/""
return ToFormat(day, layout, Format[FormatDayLongYearAtBegin2])
case 46: // "."
return ToFormat(day, layout, Format[FormatDayLongYearAtBegin3])
case 32: // ""
return ToFormat(day, layout, Format[FormatDayLongYearAtBegin4])
default:
return day, nil
}
}
// ToYYYYMMDDHHMMSS convert to YYYY-MM-DD HH24:MI:SS or YYYY/MM/DD HH24:MI:SS or YYYY.MM.DD HI:MM:SS or YYYYMMDD HH24:MI:SS
func ToYYYYMMDDHHMMSS(date, layout string, separator rune) (string, error) {
switch separator {
case 45: // "-"
return ToFormat(date, layout, Format[FormatDateLongYearAtBegin21])
case 47: // "/""
return ToFormat(date, layout, Format[FormatDateLongYearAtBegin22])
case 46: // "."
return ToFormat(date, layout, Format[FormatDateLongYearAtBegin23])
case 32: // ""
return ToFormat(date, layout, Format[FormatDateLongYearAtBegin24])
default:
return date, nil
}
}
// ToDDMMYYYY convert to DD-MM-YYYY or DD/MM/YYYY or DD.MM.YYYY or DDMMYYYY
func ToDDMMYYYY(day, layout string, separator rune) (string, error) {
switch separator {
case 45: // "-"
return ToFormat(day, layout, Format[FormatDayLongYearAtEnd1])
case 47: // "/""
return ToFormat(day, layout, Format[FormatDayLongYearAtEnd2])
case 46: // "."
return ToFormat(day, layout, Format[FormatDayLongYearAtEnd3])
case 32: // ""
return ToFormat(day, layout, Format[FormatDayLongYearAtEnd4])
default:
return day, nil
}
}
// ToDDMMYYYYHHMMSS convert to DD-MM-YYYY HH24:MI:SS or DD/MM/YYYY HH24:MI:SS or DD.MM.YYYY HI:MM:SS or DDMMYYYY HH24:MI:SS
func ToDDMMYYYYHHMMSS(date, layout string, separator rune) (string, error) {
switch separator {
case 45: // "-"
return ToFormat(date, layout, Format[FormatDateLongYearAtEnd21])
case 47: // "/""
return ToFormat(date, layout, Format[FormatDateLongYearAtEnd22])
case 46: // "."
return ToFormat(date, layout, Format[FormatDateLongYearAtEnd23])
case 32: // ""
return ToFormat(date, layout, Format[FormatDateLongYearAtEnd24])
default:
return date, nil
}
}
// TryConvertMonthRuToEn converts the name of the Russian month into the English name of the month
func TryConvertMonthRuToEn(m string) (string, bool) {
if m == "" {
return "", false
}
m = strings.ToLower(m)
m = strings.ReplaceAll(m, "ё", "е")
for ind, month := range MonthsRu {
month = strings.ToLower(month)
if month == m {
return MonthsEn[ind], true
}
}
for ind, month := range MonthsRuGenitive {
month = strings.ToLower(month)
if month == m {
return MonthsEn[ind], true
}
}
for ind, month := range MonthsRuDative {
month = strings.ToLower(month)
if month == m {
return MonthsEn[ind], true
}
}
for ind, month := range MonthsRuAccusative {
month = strings.ToLower(month)
if month == m {
return MonthsEn[ind], true
}
}
for ind, month := range MonthsRuAblative {
month = strings.ToLower(month)
if month == m {
return MonthsEn[ind], true
}
}
for ind, month := range MonthsRuPrepositional {
month = strings.ToLower(month)
if month == m {
return MonthsEn[ind], true
}
}
return "", false
} | timef.go | 0.508788 | 0.447762 | timef.go | starcoder |
package statistics
import "fmt"
type result map[string]interface{}
type statOpt func(result)
//Set flags to true to be able to configure process functions
func (d *dataBuffer) SetConfigOption(stats []string) (map[string]statOpt, error) {
statOpts := make(map[string]statOpt)
for _, stat := range stats {
switch stat {
case count:
statOpts[count] = d.countOpt
case mean:
statOpts[mean] = d.meanOpt
case median:
statOpts[median] = d.medianOpt
case standarddeviation:
statOpts[standarddeviation] = d.standardDeviationOpt
case variance:
statOpts[variance] = d.varianceOpt
case ninetyfifthpercentile:
statOpts[ninetyfifthpercentile] = d.ninetyFifthPercentileOpt
case ninetyninthpercentile:
statOpts[ninetyninthpercentile] = d.ninetyNinthPercentileOpt
case secondpercentile:
statOpts[secondpercentile] = d.secondPercentileOpt
case ninthpercentile:
statOpts[ninthpercentile] = d.ninthPercentileOpt
case twentyfifthpercentile:
statOpts[twentyfifthpercentile] = d.twentyPercentileOpt
case seventyfifthpercentile:
statOpts[seventyfifthpercentile] = d.SeventyFifthPercentileOpt
case ninetyfirstpercentile:
statOpts[ninetyfirstpercentile] = d.ninetyFirstPercentileOpt
case ninetyeighthpercentile:
statOpts[ninetyeighthpercentile] = d.ninetyEightPercentileOpt
case minimum:
statOpts[minimum] = d.minimumOpt
case maximum:
statOpts[maximum] = d.maximumOpt
case rangeval:
statOpts[rangeval] = d.rangeOpt
case mode:
statOpts[mode] = d.modesOpt
case kurtosis:
statOpts[kurtosis] = d.kurtosisOpt
case skewness:
statOpts[skewness] = d.skewnessOpt
case sum:
statOpts[sum] = d.sumOpt
case trimean:
statOpts[trimean] = d.trimeanOpt
case quartilerange:
statOpts[quartilerange] = d.quartileRangeOpt
case firstquartile:
statOpts[firstquartile] = d.firstQuartileOpt
case thirdquartile:
statOpts[thirdquartile] = d.thirdQuartileOpt
default:
return nil, fmt.Errorf("Unknown statistic received %T:", stat)
}
}
return statOpts, nil
}
// config options in order to calcul each required statistics once
func (d *dataBuffer) countOpt(result result) {
result[count] = d.Count()
}
func (d *dataBuffer) sumOpt(result result) {
result[sum] = d.Sum()
}
func (d *dataBuffer) minimumOpt(result result) {
result[minimum] = d.Minimum()
}
func (d *dataBuffer) maximumOpt(result result) {
result[maximum] = d.Maximum()
}
func (d *dataBuffer) rangeOpt(result result) {
_, ok := result[minimum]
if !ok {
d.minimumOpt(result)
}
_, ok = result[maximum]
if !ok {
d.maximumOpt(result)
}
result[rangeval] = d.Range(result[minimum].(float64), result[maximum].(float64))
}
func (d *dataBuffer) meanOpt(result result) {
_, ok := result[sum]
if !ok {
d.sumOpt(result)
}
_, ok = result[count]
if !ok {
d.countOpt(result)
}
result[mean] = d.Mean(result[sum].(float64), result[count].(int))
}
func (d *dataBuffer) medianOpt(result result) {
result[median] = d.Median()
}
func (d *dataBuffer) modesOpt(result result) {
result[mode] = d.Mode()
}
func (d *dataBuffer) firstQuartileOpt(result result) {
result[firstquartile] = d.FirstQuartile()
}
func (d *dataBuffer) thirdQuartileOpt(result result) {
result[thirdquartile] = d.ThirdQuartile()
}
func (d *dataBuffer) quartileRangeOpt(result result) {
_, ok := result[firstquartile]
if !ok {
d.firstQuartileOpt(result)
}
_, ok = result[thirdquartile]
if !ok {
d.thirdQuartileOpt(result)
}
result[quartilerange] = d.Range(result[firstquartile].(float64), result[thirdquartile].(float64))
}
func (d *dataBuffer) varianceOpt(result result) {
_, ok := result[mean]
if !ok {
d.meanOpt(result)
}
result[variance] = d.Variance(result[mean].(float64))
}
func (d *dataBuffer) standardDeviationOpt(result result) {
_, ok := result[variance]
if !ok {
d.varianceOpt(result)
}
result[standarddeviation] = d.StandardDeviation(result[variance].(float64))
}
func (d *dataBuffer) secondPercentileOpt(result result) {
result[secondpercentile], _ = d.PercentileNearestRank(2)
}
func (d *dataBuffer) ninthPercentileOpt(result result) {
result[ninthpercentile], _ = d.PercentileNearestRank(9)
}
func (d *dataBuffer) twentyPercentileOpt(result result) {
result[twentyfifthpercentile], _ = d.PercentileNearestRank(25)
}
func (d *dataBuffer) SeventyFifthPercentileOpt(result result) {
result[seventyfifthpercentile], _ = d.PercentileNearestRank(75)
}
func (d *dataBuffer) ninetyFirstPercentileOpt(result result) {
result[ninetyfirstpercentile], _ = d.PercentileNearestRank(91)
}
func (d *dataBuffer) ninetyFifthPercentileOpt(result result) {
result[ninetyfifthpercentile], _ = d.PercentileNearestRank(95)
}
func (d *dataBuffer) ninetyEightPercentileOpt(result result) {
result[ninetyeighthpercentile], _ = d.PercentileNearestRank(98)
}
func (d *dataBuffer) ninetyNinthPercentileOpt(result result) {
result[ninetyninthpercentile], _ = d.PercentileNearestRank(99)
}
func (d *dataBuffer) skewnessOpt(result result) {
_, ok := result[standarddeviation]
if !ok {
d.standardDeviationOpt(result)
}
_, ok = result[mean]
if !ok {
d.meanOpt(result)
}
result[skewness] = d.Skewness(result[mean].(float64), result[standarddeviation].(float64))
}
func (d *dataBuffer) kurtosisOpt(result result) {
_, ok := result[standarddeviation]
if !ok {
d.standardDeviationOpt(result)
}
_, ok = result[mean]
if !ok {
d.meanOpt(result)
}
result[kurtosis] = d.Kurtosis(result[mean].(float64), result[standarddeviation].(float64))
}
func (d *dataBuffer) trimeanOpt(result result) {
_, ok := result[thirdquartile]
if !ok {
d.thirdQuartileOpt(result)
}
_, ok = result[median]
if !ok {
d.medianOpt(result)
}
_, ok = result[firstquartile]
if !ok {
d.firstQuartileOpt(result)
}
result[trimean] = d.Trimean(result[firstquartile].(float64), result[median].(float64), result[thirdquartile].(float64))
} | statistics/options.go | 0.579043 | 0.461805 | options.go | starcoder |
package continuous
import (
"github.com/jtejido/ggsl/specfunc"
"github.com/jtejido/stats"
"github.com/jtejido/stats/err"
smath "github.com/jtejido/stats/math"
"math"
"math/rand"
)
// Beta distribution
// https://en.wikipedia.org/wiki/Beta_distribution
type Beta struct {
baseContinuousWithSource
alpha, beta float64 // α, β
}
func NewBeta(alpha, beta float64) (*Beta, error) {
return NewBetaWithSource(alpha, beta, nil)
}
func NewBetaWithSource(alpha, beta float64, src rand.Source) (*Beta, error) {
if alpha <= 0 || beta <= 0 {
return nil, err.Invalid()
}
ret := new(Beta)
ret.alpha = alpha
ret.beta = beta
ret.src = src
return ret, nil
}
func (b *Beta) String() string {
return "Beta: Parameters - " + b.Parameters().String() + ", Support(x) - " + b.Support().String()
}
// α ∈ (0,∞)
// β ∈ (0,∞)
func (b *Beta) Parameters() stats.Limits {
return stats.Limits{
"α": stats.Interval{0, math.Inf(1), true, true},
"β": stats.Interval{0, math.Inf(1), true, true},
}
}
// x ∈ [0,1]
func (b *Beta) Support() stats.Interval {
return stats.Interval{0, 1, false, false}
}
func (b *Beta) Probability(x float64) float64 {
if b.Support().IsWithinInterval(x) {
xPowam1 := math.Pow(x, b.alpha-1.)
xm1Powbm1 := math.Pow(1.-x, b.beta-1.)
b_ab := specfunc.Beta(b.alpha, b.beta)
return (xPowam1 * xm1Powbm1) / b_ab
}
return 0
}
func (b *Beta) Distribution(x float64) float64 {
if b.Support().IsWithinInterval(x) {
return specfunc.Beta_inc(b.alpha, b.beta, x)
}
return 0
}
func (b *Beta) Entropy() float64 {
if b.alpha <= 0 || b.beta <= 0 {
panic("b: negative parameters")
}
return specfunc.Lnbeta(b.alpha, b.beta) - (b.alpha-1)*specfunc.Psi(b.alpha) -
(b.beta-1)*specfunc.Psi(b.beta) + (b.alpha+b.beta-2)*specfunc.Psi(b.alpha+b.beta)
}
func (b *Beta) ExKurtosis() float64 {
num := 6 * (((b.alpha-b.beta)*(b.alpha-b.beta))*(b.alpha+b.beta+1) - b.alpha*b.beta*(b.alpha+b.beta+2))
den := b.alpha * b.beta * (b.alpha + b.beta + 2) * (b.alpha + b.beta + 3)
return num / den
}
func (b *Beta) Skewness() float64 {
num := 2 * (b.beta - b.alpha) * math.Sqrt(b.alpha+b.beta+1)
denom := (b.alpha + b.beta + 2) * math.Sqrt(b.alpha*b.beta)
return num / denom
}
func (b *Beta) Inverse(q float64) float64 {
if q <= 0 {
return 0
}
if q >= 1 {
return 1
}
return smath.InverseRegularizedIncompleteBeta(b.alpha, b.beta, q)
}
func (b *Beta) Mean() float64 {
return b.alpha / (b.alpha + b.beta)
}
func (b *Beta) Median() float64 {
if b.alpha == b.beta {
return 0.5
}
if b.alpha == 1 && b.beta > 0 {
return 1 - math.Pow(2., (-1/b.beta))
}
if b.beta == 1 && b.alpha > 0 {
return math.Pow(2., (-1 / b.alpha))
}
if b.alpha == 3 && b.beta == 2 {
return 0.6142724318676105
}
if b.alpha == 2 && b.beta == 3 {
return 0.38572756813238945
}
return (b.alpha - 1./3) / (b.alpha + b.beta - 2./3)
}
func (b *Beta) Mode() float64 {
if b.alpha == 1 && b.beta > 1 {
return 0
}
if b.alpha > 1 && b.beta == 1 {
return 1
}
return (b.alpha - 1.) / (b.alpha + b.beta - 2.)
}
func (b *Beta) Variance() float64 {
ab := b.alpha * b.beta
aPowbSqrd := (b.alpha + b.beta) * (b.alpha + b.beta)
apbp1 := b.alpha + b.beta + 1.
return ab / (aPowbSqrd * apbp1)
}
func (b *Beta) Rand() float64 {
if (b.alpha <= 1.0) && (b.beta <= 1.0) {
for {
u := rand.Float64()
v := rand.Float64()
if b.src != nil {
r := rand.New(b.src)
u = r.Float64()
v = r.Float64()
}
x := math.Pow(u, 1/b.alpha)
y := math.Pow(v, 1/b.beta)
if (x + y) <= 1 {
if (x + y) > 0 {
return x / (x + y)
} else {
logX := math.Log(u) / b.alpha
logY := math.Log(v) / b.beta
logM := logY
if logX > logY {
logM = logX
}
logX -= logM
logY -= logM
return math.Exp(logX - math.Log(math.Exp(logX)+math.Exp(logY)))
}
}
}
} else {
var gas, gbs Gamma
gas.shape = b.alpha
gas.rate = 1
gas.src = b.src
gbs.shape = b.beta
gbs.rate = 1
gbs.src = b.src
ga := gas.Rand()
gb := gbs.Rand()
return ga / (ga + gb)
}
} | dist/continuous/beta.go | 0.724578 | 0.456289 | beta.go | starcoder |
package noise
import (
"net"
"time"
"go.uber.org/zap"
)
// NodeOption represents a functional option that may be passed to NewNode for instantiating a new node instance with configured values
type NodeOption func(n *Node)
// WithNodeMaxDialAttempts sets the max number of attempts a connection is dialed before it is determined to have
// failed. By default, the max number of attempts a connection is dialed is 3.
func WithNodeMaxDialAttempts(maxDialAttempts uint) NodeOption {
return func(n *Node) {
if maxDialAttempts == 0 {
maxDialAttempts = 1
}
n.maxDialAttempts = maxDialAttempts
}
}
// WithNodeMaxInboundConnections sets the max number of inbound connections the connection pool a node maintains allows
// at any given moment in time. By default, the max number of inbound connections is 128. Exceeding the max number
// causes the connection pool to release the oldest inbound connection in the pool.
func WithNodeMaxInboundConnections(maxInboundConnections uint) NodeOption {
return func(n *Node) {
if maxInboundConnections == 0 {
maxInboundConnections = 128
}
n.maxInboundConnections = maxInboundConnections
}
}
// WithNodeMaxOutboundConnections sets the max number of outbound connections the connection pool a node maintains
// allows at any given moment in time. By default, the maximum number of outbound connections is 128. Exceeding the
// max number causes the connection pool to release the oldest outbound connection in the pool.
func WithNodeMaxOutboundConnections(maxOutboundConnections uint) NodeOption {
return func(n *Node) {
if maxOutboundConnections == 0 {
maxOutboundConnections = 128
}
n.maxOutboundConnections = maxOutboundConnections
}
}
// WithNodeMaxRecvMessageSize sets the max number of bytes a node is willing to receive from a peer. If the limit is
// ever exceeded, the peer is disconnected with an error. Setting this option to zero will disable the limit. By
// default, the max number of bytes a node is willing to receive from a peer is set to 4MB.
func WithNodeMaxRecvMessageSize(maxRecvMessageSize uint32) NodeOption {
return func(n *Node) {
n.maxRecvMessageSize = maxRecvMessageSize
}
}
// WithNodeNumWorkers sets the max number of workers a node will spawn to handle incoming peer messages. By default,
// the max number of workers a node will spawn is the number of CPUs available to the Go runtime specified by
// runtime.NumCPU(). The minimum number of workers which need to be spawned is 1.
func WithNodeNumWorkers(numWorkers uint) NodeOption {
return func(n *Node) {
if numWorkers == 0 {
numWorkers = 1
}
n.numWorkers = numWorkers
}
}
// WithNodeIdleTimeout sets the duration in which should there be no subsequent reads/writes on a connection, the
// connection shall timeout and have resources related to it released. By default, the timeout is set to be 3 seconds.
// If an idle timeout of 0 is specified, idle timeouts will be disabled.
func WithNodeIdleTimeout(idleTimeout time.Duration) NodeOption {
return func(n *Node) {
n.idleTimeout = idleTimeout
}
}
// WithNodeLogger sets the logger implementation that the node shall use. By default, zap.NewNop() is assigned which
// disables any logs.
func WithNodeLogger(logger *zap.Logger) NodeOption {
return func(n *Node) {
if logger == nil {
logger = zap.NewNop()
}
n.logger = logger
}
}
// WithNodeID sets the nodes ID, and public address. By default, the ID is set with an address that is set to the
// binding host and port upon calling (*Node).Listen should the address not be configured.
func WithNodeID(id ID) NodeOption {
return func(n *Node) {
n.id = id
n.addr = id.Address
}
}
// WithNodePrivateKey sets the private key of the node. By default, a random private key is generated using
// GenerateKeys should no private key be configured.
func WithNodePrivateKey(privateKey PrivateKey) NodeOption {
return func(n *Node) {
n.privateKey = privateKey
}
}
// WithNodeBindHost sets the TCP host IP address which the node binds itself to and listens for new incoming peer
// connections on. By default, it is unspecified (0.0.0.0).
func WithNodeBindHost(host net.IP) NodeOption {
return func(n *Node) {
n.host = host
}
}
// WithNodeBindPort sets the TCP port which the node binds itself to and listens for new incoming peer connections on.
// By default, a random port is assigned by the operating system.
func WithNodeBindPort(port uint16) NodeOption {
return func(n *Node) {
n.port = port
}
}
// WithNodeAddress sets the public address of this node which is advertised on the ID sent to peers during a handshake
// protocol which is performed when interacting with peers this node has had no live connection to beforehand. By
// default, it is left blank, and initialized to 'binding host:binding port' upon calling (*Node).Listen.
func WithNodeAddress(addr string) NodeOption {
return func(n *Node) {
n.addr = addr
}
} | node_options.go | 0.783409 | 0.482856 | node_options.go | starcoder |
package models
import (
i336074805fc853987abe6f7fe3ad97a6a6f3077a16391fec744f671a015fbd7e "time"
i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91 "github.com/microsoft/kiota-abstractions-go/serialization"
)
// SimulationAutomation
type SimulationAutomation struct {
Entity
// Identity of the user who created the attack simulation automation.
createdBy EmailIdentityable
// Date and time when the attack simulation automation was created.
createdDateTime *i336074805fc853987abe6f7fe3ad97a6a6f3077a16391fec744f671a015fbd7e.Time
// Description of the attack simulation automation.
description *string
// Display name of the attack simulation automation. Supports $filter and $orderby.
displayName *string
// Identity of the user who most recently modified the attack simulation automation.
lastModifiedBy EmailIdentityable
// Date and time when the attack simulation automation was most recently modified.
lastModifiedDateTime *i336074805fc853987abe6f7fe3ad97a6a6f3077a16391fec744f671a015fbd7e.Time
// Date and time of the latest run of the attack simulation automation.
lastRunDateTime *i336074805fc853987abe6f7fe3ad97a6a6f3077a16391fec744f671a015fbd7e.Time
// Date and time of the upcoming run of the attack simulation automation.
nextRunDateTime *i336074805fc853987abe6f7fe3ad97a6a6f3077a16391fec744f671a015fbd7e.Time
// A collection of simulation automation runs.
runs []SimulationAutomationRunable
// Status of the attack simulation automation. Supports $filter and $orderby. The possible values are: unknown, draft, notRunning, running, completed, unknownFutureValue.
status *SimulationAutomationStatus
}
// NewSimulationAutomation instantiates a new simulationAutomation and sets the default values.
func NewSimulationAutomation()(*SimulationAutomation) {
m := &SimulationAutomation{
Entity: *NewEntity(),
}
return m
}
// CreateSimulationAutomationFromDiscriminatorValue creates a new instance of the appropriate class based on discriminator value
func CreateSimulationAutomationFromDiscriminatorValue(parseNode i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.ParseNode)(i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.Parsable, error) {
return NewSimulationAutomation(), nil
}
// GetCreatedBy gets the createdBy property value. Identity of the user who created the attack simulation automation.
func (m *SimulationAutomation) GetCreatedBy()(EmailIdentityable) {
if m == nil {
return nil
} else {
return m.createdBy
}
}
// GetCreatedDateTime gets the createdDateTime property value. Date and time when the attack simulation automation was created.
func (m *SimulationAutomation) GetCreatedDateTime()(*i336074805fc853987abe6f7fe3ad97a6a6f3077a16391fec744f671a015fbd7e.Time) {
if m == nil {
return nil
} else {
return m.createdDateTime
}
}
// GetDescription gets the description property value. Description of the attack simulation automation.
func (m *SimulationAutomation) GetDescription()(*string) {
if m == nil {
return nil
} else {
return m.description
}
}
// GetDisplayName gets the displayName property value. Display name of the attack simulation automation. Supports $filter and $orderby.
func (m *SimulationAutomation) GetDisplayName()(*string) {
if m == nil {
return nil
} else {
return m.displayName
}
}
// GetFieldDeserializers the deserialization information for the current model
func (m *SimulationAutomation) GetFieldDeserializers()(map[string]func(i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.ParseNode)(error)) {
res := m.Entity.GetFieldDeserializers()
res["createdBy"] = func (n i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.ParseNode) error {
val, err := n.GetObjectValue(CreateEmailIdentityFromDiscriminatorValue)
if err != nil {
return err
}
if val != nil {
m.SetCreatedBy(val.(EmailIdentityable))
}
return nil
}
res["createdDateTime"] = func (n i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.ParseNode) error {
val, err := n.GetTimeValue()
if err != nil {
return err
}
if val != nil {
m.SetCreatedDateTime(val)
}
return nil
}
res["description"] = func (n i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.ParseNode) error {
val, err := n.GetStringValue()
if err != nil {
return err
}
if val != nil {
m.SetDescription(val)
}
return nil
}
res["displayName"] = func (n i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.ParseNode) error {
val, err := n.GetStringValue()
if err != nil {
return err
}
if val != nil {
m.SetDisplayName(val)
}
return nil
}
res["lastModifiedBy"] = func (n i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.ParseNode) error {
val, err := n.GetObjectValue(CreateEmailIdentityFromDiscriminatorValue)
if err != nil {
return err
}
if val != nil {
m.SetLastModifiedBy(val.(EmailIdentityable))
}
return nil
}
res["lastModifiedDateTime"] = func (n i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.ParseNode) error {
val, err := n.GetTimeValue()
if err != nil {
return err
}
if val != nil {
m.SetLastModifiedDateTime(val)
}
return nil
}
res["lastRunDateTime"] = func (n i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.ParseNode) error {
val, err := n.GetTimeValue()
if err != nil {
return err
}
if val != nil {
m.SetLastRunDateTime(val)
}
return nil
}
res["nextRunDateTime"] = func (n i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.ParseNode) error {
val, err := n.GetTimeValue()
if err != nil {
return err
}
if val != nil {
m.SetNextRunDateTime(val)
}
return nil
}
res["runs"] = func (n i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.ParseNode) error {
val, err := n.GetCollectionOfObjectValues(CreateSimulationAutomationRunFromDiscriminatorValue)
if err != nil {
return err
}
if val != nil {
res := make([]SimulationAutomationRunable, len(val))
for i, v := range val {
res[i] = v.(SimulationAutomationRunable)
}
m.SetRuns(res)
}
return nil
}
res["status"] = func (n i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.ParseNode) error {
val, err := n.GetEnumValue(ParseSimulationAutomationStatus)
if err != nil {
return err
}
if val != nil {
m.SetStatus(val.(*SimulationAutomationStatus))
}
return nil
}
return res
}
// GetLastModifiedBy gets the lastModifiedBy property value. Identity of the user who most recently modified the attack simulation automation.
func (m *SimulationAutomation) GetLastModifiedBy()(EmailIdentityable) {
if m == nil {
return nil
} else {
return m.lastModifiedBy
}
}
// GetLastModifiedDateTime gets the lastModifiedDateTime property value. Date and time when the attack simulation automation was most recently modified.
func (m *SimulationAutomation) GetLastModifiedDateTime()(*i336074805fc853987abe6f7fe3ad97a6a6f3077a16391fec744f671a015fbd7e.Time) {
if m == nil {
return nil
} else {
return m.lastModifiedDateTime
}
}
// GetLastRunDateTime gets the lastRunDateTime property value. Date and time of the latest run of the attack simulation automation.
func (m *SimulationAutomation) GetLastRunDateTime()(*i336074805fc853987abe6f7fe3ad97a6a6f3077a16391fec744f671a015fbd7e.Time) {
if m == nil {
return nil
} else {
return m.lastRunDateTime
}
}
// GetNextRunDateTime gets the nextRunDateTime property value. Date and time of the upcoming run of the attack simulation automation.
func (m *SimulationAutomation) GetNextRunDateTime()(*i336074805fc853987abe6f7fe3ad97a6a6f3077a16391fec744f671a015fbd7e.Time) {
if m == nil {
return nil
} else {
return m.nextRunDateTime
}
}
// GetRuns gets the runs property value. A collection of simulation automation runs.
func (m *SimulationAutomation) GetRuns()([]SimulationAutomationRunable) {
if m == nil {
return nil
} else {
return m.runs
}
}
// GetStatus gets the status property value. Status of the attack simulation automation. Supports $filter and $orderby. The possible values are: unknown, draft, notRunning, running, completed, unknownFutureValue.
func (m *SimulationAutomation) GetStatus()(*SimulationAutomationStatus) {
if m == nil {
return nil
} else {
return m.status
}
}
// Serialize serializes information the current object
func (m *SimulationAutomation) Serialize(writer i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.SerializationWriter)(error) {
err := m.Entity.Serialize(writer)
if err != nil {
return err
}
{
err = writer.WriteObjectValue("createdBy", m.GetCreatedBy())
if err != nil {
return err
}
}
{
err = writer.WriteTimeValue("createdDateTime", m.GetCreatedDateTime())
if err != nil {
return err
}
}
{
err = writer.WriteStringValue("description", m.GetDescription())
if err != nil {
return err
}
}
{
err = writer.WriteStringValue("displayName", m.GetDisplayName())
if err != nil {
return err
}
}
{
err = writer.WriteObjectValue("lastModifiedBy", m.GetLastModifiedBy())
if err != nil {
return err
}
}
{
err = writer.WriteTimeValue("lastModifiedDateTime", m.GetLastModifiedDateTime())
if err != nil {
return err
}
}
{
err = writer.WriteTimeValue("lastRunDateTime", m.GetLastRunDateTime())
if err != nil {
return err
}
}
{
err = writer.WriteTimeValue("nextRunDateTime", m.GetNextRunDateTime())
if err != nil {
return err
}
}
if m.GetRuns() != nil {
cast := make([]i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.Parsable, len(m.GetRuns()))
for i, v := range m.GetRuns() {
cast[i] = v.(i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.Parsable)
}
err = writer.WriteCollectionOfObjectValues("runs", cast)
if err != nil {
return err
}
}
if m.GetStatus() != nil {
cast := (*m.GetStatus()).String()
err = writer.WriteStringValue("status", &cast)
if err != nil {
return err
}
}
return nil
}
// SetCreatedBy sets the createdBy property value. Identity of the user who created the attack simulation automation.
func (m *SimulationAutomation) SetCreatedBy(value EmailIdentityable)() {
if m != nil {
m.createdBy = value
}
}
// SetCreatedDateTime sets the createdDateTime property value. Date and time when the attack simulation automation was created.
func (m *SimulationAutomation) SetCreatedDateTime(value *i336074805fc853987abe6f7fe3ad97a6a6f3077a16391fec744f671a015fbd7e.Time)() {
if m != nil {
m.createdDateTime = value
}
}
// SetDescription sets the description property value. Description of the attack simulation automation.
func (m *SimulationAutomation) SetDescription(value *string)() {
if m != nil {
m.description = value
}
}
// SetDisplayName sets the displayName property value. Display name of the attack simulation automation. Supports $filter and $orderby.
func (m *SimulationAutomation) SetDisplayName(value *string)() {
if m != nil {
m.displayName = value
}
}
// SetLastModifiedBy sets the lastModifiedBy property value. Identity of the user who most recently modified the attack simulation automation.
func (m *SimulationAutomation) SetLastModifiedBy(value EmailIdentityable)() {
if m != nil {
m.lastModifiedBy = value
}
}
// SetLastModifiedDateTime sets the lastModifiedDateTime property value. Date and time when the attack simulation automation was most recently modified.
func (m *SimulationAutomation) SetLastModifiedDateTime(value *i336074805fc853987abe6f7fe3ad97a6a6f3077a16391fec744f671a015fbd7e.Time)() {
if m != nil {
m.lastModifiedDateTime = value
}
}
// SetLastRunDateTime sets the lastRunDateTime property value. Date and time of the latest run of the attack simulation automation.
func (m *SimulationAutomation) SetLastRunDateTime(value *i336074805fc853987abe6f7fe3ad97a6a6f3077a16391fec744f671a015fbd7e.Time)() {
if m != nil {
m.lastRunDateTime = value
}
}
// SetNextRunDateTime sets the nextRunDateTime property value. Date and time of the upcoming run of the attack simulation automation.
func (m *SimulationAutomation) SetNextRunDateTime(value *i336074805fc853987abe6f7fe3ad97a6a6f3077a16391fec744f671a015fbd7e.Time)() {
if m != nil {
m.nextRunDateTime = value
}
}
// SetRuns sets the runs property value. A collection of simulation automation runs.
func (m *SimulationAutomation) SetRuns(value []SimulationAutomationRunable)() {
if m != nil {
m.runs = value
}
}
// SetStatus sets the status property value. Status of the attack simulation automation. Supports $filter and $orderby. The possible values are: unknown, draft, notRunning, running, completed, unknownFutureValue.
func (m *SimulationAutomation) SetStatus(value *SimulationAutomationStatus)() {
if m != nil {
m.status = value
}
} | models/simulation_automation.go | 0.557604 | 0.404302 | simulation_automation.go | starcoder |
package xpath
import (
"fmt"
"reflect"
"strconv"
)
// The XPath number operator function list.
// valueType is a return value type.
type valueType int
const (
booleanType valueType = iota
numberType
stringType
nodeSetType
)
func getValueType(i interface{}) valueType {
v := reflect.ValueOf(i)
switch v.Kind() {
case reflect.Float64:
return numberType
case reflect.String:
return stringType
case reflect.Bool:
return booleanType
default:
if _, ok := i.(query); ok {
return nodeSetType
}
}
panic(fmt.Errorf("xpath unknown value type: %v", v.Kind()))
}
type logical func(iterator, string, interface{}, interface{}) bool
var logicalFuncs = [][]logical{
{cmpBooleanBoolean, nil, nil, nil},
{nil, cmpNumericNumeric, cmpNumericString, cmpNumericNodeSet},
{nil, cmpStringNumeric, cmpStringString, cmpStringNodeSet},
{nil, cmpNodeSetNumeric, cmpNodeSetString, cmpNodeSetNodeSet},
}
// number vs number
func cmpNumberNumberF(op string, a, b float64) bool {
switch op {
case "=":
return a == b
case ">":
return a > b
case "<":
return a < b
case ">=":
return a >= b
case "<=":
return a <= b
case "!=":
return a != b
}
return false
}
// string vs string
func cmpStringStringF(op string, a, b string) bool {
switch op {
case "=":
return a == b
case ">":
return a > b
case "<":
return a < b
case ">=":
return a >= b
case "<=":
return a <= b
case "!=":
return a != b
}
return false
}
func cmpBooleanBooleanF(op string, a, b bool) bool {
switch op {
case "or":
return a || b
case "and":
return a && b
}
return false
}
func cmpNumericNumeric(t iterator, op string, m, n interface{}) bool {
a := m.(float64)
b := n.(float64)
return cmpNumberNumberF(op, a, b)
}
func cmpNumericString(t iterator, op string, m, n interface{}) bool {
a := m.(float64)
b := n.(string)
num, err := strconv.ParseFloat(b, 64)
if err != nil {
panic(err)
}
return cmpNumberNumberF(op, a, num)
}
func cmpNumericNodeSet(t iterator, op string, m, n interface{}) bool {
a := m.(float64)
b := n.(query)
for {
node := b.Select(t)
if node == nil {
break
}
num, err := strconv.ParseFloat(node.Value(), 64)
if err != nil {
panic(err)
}
if cmpNumberNumberF(op, a, num) {
return true
}
}
return false
}
func cmpNodeSetNumeric(t iterator, op string, m, n interface{}) bool {
a := m.(query)
b := n.(float64)
for {
node := a.Select(t)
if node == nil {
break
}
num, err := strconv.ParseFloat(node.Value(), 64)
if err != nil {
panic(err)
}
if cmpNumberNumberF(op, num, b) {
return true
}
}
return false
}
func cmpNodeSetString(t iterator, op string, m, n interface{}) bool {
a := m.(query)
b := n.(string)
for {
node := a.Select(t)
if node == nil {
break
}
if cmpStringStringF(op, b, node.Value()) {
return true
}
}
return false
}
func cmpNodeSetNodeSet(t iterator, op string, m, n interface{}) bool {
a := m.(query)
b := n.(query)
x := a.Select(t)
if x == nil {
return false
}
y := b.Select(t)
if y == nil {
return false
}
return cmpStringStringF(op, x.Value(), y.Value())
}
func cmpStringNumeric(t iterator, op string, m, n interface{}) bool {
a := m.(string)
b := n.(float64)
num, err := strconv.ParseFloat(a, 64)
if err != nil {
panic(err)
}
return cmpNumberNumberF(op, b, num)
}
func cmpStringString(t iterator, op string, m, n interface{}) bool {
a := m.(string)
b := n.(string)
return cmpStringStringF(op, a, b)
}
func cmpStringNodeSet(t iterator, op string, m, n interface{}) bool {
a := m.(string)
b := n.(query)
for {
node := b.Select(t)
if node == nil {
break
}
if cmpStringStringF(op, a, node.Value()) {
return true
}
}
return false
}
func cmpBooleanBoolean(t iterator, op string, m, n interface{}) bool {
a := m.(bool)
b := n.(bool)
return cmpBooleanBooleanF(op, a, b)
}
// eqFunc is an `=` operator.
func eqFunc(t iterator, m, n interface{}) interface{} {
t1 := getValueType(m)
t2 := getValueType(n)
return logicalFuncs[t1][t2](t, "=", m, n)
}
// gtFunc is an `>` operator.
func gtFunc(t iterator, m, n interface{}) interface{} {
t1 := getValueType(m)
t2 := getValueType(n)
return logicalFuncs[t1][t2](t, ">", m, n)
}
// geFunc is an `>=` operator.
func geFunc(t iterator, m, n interface{}) interface{} {
t1 := getValueType(m)
t2 := getValueType(n)
return logicalFuncs[t1][t2](t, ">=", m, n)
}
// ltFunc is an `<` operator.
func ltFunc(t iterator, m, n interface{}) interface{} {
t1 := getValueType(m)
t2 := getValueType(n)
return logicalFuncs[t1][t2](t, "<", m, n)
}
// leFunc is an `<=` operator.
func leFunc(t iterator, m, n interface{}) interface{} {
t1 := getValueType(m)
t2 := getValueType(n)
return logicalFuncs[t1][t2](t, "<=", m, n)
}
// neFunc is an `!=` operator.
func neFunc(t iterator, m, n interface{}) interface{} {
t1 := getValueType(m)
t2 := getValueType(n)
return logicalFuncs[t1][t2](t, "!=", m, n)
}
// orFunc is an `or` operator.
var orFunc = func(t iterator, m, n interface{}) interface{} {
t1 := getValueType(m)
t2 := getValueType(n)
return logicalFuncs[t1][t2](t, "or", m, n)
}
func numericExpr(m, n interface{}, cb func(float64, float64) float64) float64 {
typ := reflect.TypeOf(float64(0))
a := reflect.ValueOf(m).Convert(typ)
b := reflect.ValueOf(n).Convert(typ)
return cb(a.Float(), b.Float())
}
// plusFunc is an `+` operator.
var plusFunc = func(m, n interface{}) interface{} {
return numericExpr(m, n, func(a, b float64) float64 {
return a + b
})
}
// minusFunc is an `-` operator.
var minusFunc = func(m, n interface{}) interface{} {
return numericExpr(m, n, func(a, b float64) float64 {
return a - b
})
}
// mulFunc is an `*` operator.
var mulFunc = func(m, n interface{}) interface{} {
return numericExpr(m, n, func(a, b float64) float64 {
return a * b
})
}
// divFunc is an `DIV` operator.
var divFunc = func(m, n interface{}) interface{} {
return numericExpr(m, n, func(a, b float64) float64 {
return a / b
})
}
// modFunc is an 'MOD' operator.
var modFunc = func(m, n interface{}) interface{} {
return numericExpr(m, n, func(a, b float64) float64 {
return float64(int(a) % int(b))
})
} | operator.go | 0.670069 | 0.441733 | operator.go | starcoder |
package interpreter
import (
"strconv"
"github.com/horvatic/vaticlang/pkg/parser"
"github.com/horvatic/vaticlang/pkg/token"
)
func isMath(tokenType token.TokenType) bool {
return tokenType == token.Plus || tokenType == token.Subtract
}
func mathMode(node *parser.Node, dataStore *DataStore) int {
if node.GetTokenType() == token.Plus {
return addMode(node, dataStore)
} else if node.GetTokenType() == token.Subtract {
return subtractMode(node, dataStore)
}
panic("no math modes")
}
func addMode(node *parser.Node, dataStore *DataStore) int {
total := 0
for i, n := range node.GetLeafs() {
if n.GetTokenType() == token.Number || n.GetTokenType() == token.Label {
if i == 0 {
if n.GetTokenType() == token.Number {
total = convertToInt(n.GetVal())
} else if n.GetTokenType() == token.Label {
total = convertToInt(dataStore.GetData(n.GetVal().(string)))
} else {
panic("unknown symbol")
}
} else {
if n.GetTokenType() == token.Number {
total += convertToInt(n.GetVal())
} else if n.GetTokenType() == token.Label {
total += convertToInt(dataStore.GetData(n.GetVal().(string)))
} else {
panic("unknown symbol")
}
}
} else if n.GetTokenType() == token.Plus {
total += addMode(n, dataStore)
} else if n.GetTokenType() == token.Subtract {
total -= subtractMode(n, dataStore)
}
}
return total
}
func subtractMode(node *parser.Node, dataStore *DataStore) int {
total := 0
for i, n := range node.GetLeafs() {
if n.GetTokenType() == token.Number || n.GetTokenType() == token.Label {
if i == 0 {
if n.GetTokenType() == token.Number {
total = convertToInt(n.GetVal())
} else if n.GetTokenType() == token.Label {
total = convertToInt(dataStore.GetData(n.GetVal().(string)))
} else {
panic("unknown symbol")
}
} else {
if n.GetTokenType() == token.Number {
total -= convertToInt(n.GetVal())
} else if n.GetTokenType() == token.Label {
total -= convertToInt(dataStore.GetData(n.GetVal().(string)))
} else {
panic("unknown symbol")
}
}
} else if n.GetTokenType() == token.Plus {
total += addMode(n, dataStore)
} else if n.GetTokenType() == token.Subtract {
total -= subtractMode(n, dataStore)
}
}
return total
}
func convertToInt(val interface{}) int {
if i, ok := val.(int); ok {
return i
}
n, err := strconv.Atoi(val.(string))
if err != nil {
panic(err)
}
return n
} | pkg/interpreter/math.go | 0.533884 | 0.414958 | math.go | starcoder |
package mlpack
/*
#cgo CFLAGS: -I./capi -Wall
#cgo LDFLAGS: -L. -lmlpack_go_mean_shift
#include <capi/mean_shift.h>
#include <stdlib.h>
*/
import "C"
import "gonum.org/v1/gonum/mat"
type MeanShiftOptionalParam struct {
ForceConvergence bool
InPlace bool
LabelsOnly bool
MaxIterations int
Radius float64
Verbose bool
}
func MeanShiftOptions() *MeanShiftOptionalParam {
return &MeanShiftOptionalParam{
ForceConvergence: false,
InPlace: false,
LabelsOnly: false,
MaxIterations: 1000,
Radius: 0,
Verbose: false,
}
}
/*
This program performs mean shift clustering on the given dataset, storing the
learned cluster assignments either as a column of labels in the input dataset
or separately.
The input dataset should be specified with the "Input" parameter, and the
radius used for search can be specified with the "Radius" parameter. The
maximum number of iterations before algorithm termination is controlled with
the "MaxIterations" parameter.
The output labels may be saved with the "Output" output parameter and the
centroids of each cluster may be saved with the "Centroid" output parameter.
For example, to run mean shift clustering on the dataset data and store the
centroids to centroids, the following command may be used:
// Initialize optional parameters for MeanShift().
param := mlpack.MeanShiftOptions()
centroids, _ := mlpack.MeanShift(data, param)
Input parameters:
- input (mat.Dense): Input dataset to perform clustering on.
- ForceConvergence (bool): If specified, the mean shift algorithm will
continue running regardless of max_iterations until the clusters
converge.
- InPlace (bool): If specified, a column containing the learned cluster
assignments will be added to the input dataset file. In this case,
--output_file is overridden. (Do not use with Python.)
- LabelsOnly (bool): If specified, only the output labels will be
written to the file specified by --output_file.
- MaxIterations (int): Maximum number of iterations before mean shift
terminates. Default value 1000.
- Radius (float64): If the distance between two centroids is less than
the given radius, one will be removed. A radius of 0 or less means an
estimate will be calculated and used for the radius. Default value 0.
- Verbose (bool): Display informational messages and the full list of
parameters and timers at the end of execution.
Output parameters:
- centroid (mat.Dense): If specified, the centroids of each cluster
will be written to the given matrix.
- output (mat.Dense): Matrix to write output labels or labeled data
to.
*/
func MeanShift(input *mat.Dense, param *MeanShiftOptionalParam) (*mat.Dense, *mat.Dense) {
resetTimers()
enableTimers()
disableBacktrace()
disableVerbose()
restoreSettings("Mean Shift Clustering")
// Detect if the parameter was passed; set if so.
gonumToArmaMat("input", input)
setPassed("input")
// Detect if the parameter was passed; set if so.
if param.ForceConvergence != false {
setParamBool("force_convergence", param.ForceConvergence)
setPassed("force_convergence")
}
// Detect if the parameter was passed; set if so.
if param.InPlace != false {
setParamBool("in_place", param.InPlace)
setPassed("in_place")
}
// Detect if the parameter was passed; set if so.
if param.LabelsOnly != false {
setParamBool("labels_only", param.LabelsOnly)
setPassed("labels_only")
}
// Detect if the parameter was passed; set if so.
if param.MaxIterations != 1000 {
setParamInt("max_iterations", param.MaxIterations)
setPassed("max_iterations")
}
// Detect if the parameter was passed; set if so.
if param.Radius != 0 {
setParamDouble("radius", param.Radius)
setPassed("radius")
}
// Detect if the parameter was passed; set if so.
if param.Verbose != false {
setParamBool("verbose", param.Verbose)
setPassed("verbose")
enableVerbose()
}
// Mark all output options as passed.
setPassed("centroid")
setPassed("output")
// Call the mlpack program.
C.mlpackMeanShift()
// Initialize result variable and get output.
var centroidPtr mlpackArma
centroid := centroidPtr.armaToGonumMat("centroid")
var outputPtr mlpackArma
output := outputPtr.armaToGonumMat("output")
// Clear settings.
clearSettings()
// Return output(s).
return centroid, output
} | mean_shift.go | 0.707101 | 0.436802 | mean_shift.go | starcoder |
package miner
import (
"math"
"sync"
"github.com/ubclaunchpad/cumulus/blockchain"
"github.com/ubclaunchpad/cumulus/common/util"
"github.com/ubclaunchpad/cumulus/consensus"
)
const (
// Paused represents the MinerState where the miner is not running but the
// previously running mining job can be resumed or stopped.
Paused = iota
// Stopped represents the MinerState where the miner is not mining anything.
Stopped
// Running represents the MinerState where the miner is actively mining.
Running
)
const (
// MiningSuccessful is returned when the miner mines a block.
MiningSuccessful = iota
// MiningNeverStarted is returned when the block header is invalid.
MiningNeverStarted
// MiningHalted is returned when the app halts the miner.
MiningHalted
)
// MiningResult contains the result of the mining operation.
type MiningResult struct {
Complete bool
Info int
}
// MinerState represents the state of the miner
type MinerState int
// Miner represents the state of of the current mining job (or lack thereof).
type Miner struct {
// state represents the state of the miner at any given time
state MinerState
// stateLock is a read/write lock to check the state variable
stateLock *sync.RWMutex
// stop signals to the miner to abort the current mining job immediately.
stop chan bool
// resume signals to the miner that it can continue mining from its previous
// state.
resume chan bool
// pause signals to the miner to pause mining and wait for a stop or resume
// signal.
pause chan bool
}
// New returns a new miner.
func New() *Miner {
return &Miner{
state: Stopped,
stateLock: &sync.RWMutex{},
stop: make(chan bool),
resume: make(chan bool),
pause: make(chan bool),
}
}
// Mine continuously increases the nonce and tries to verify the proof of work
// until the puzzle is solved.
func (m *Miner) Mine(b *blockchain.Block) *MiningResult {
m.setState(Running)
miningHalted := &MiningResult{
Complete: false,
Info: MiningHalted,
}
for !m.VerifyProofOfWork(b) {
// Check if we should keep mining.
select {
case <-m.pause:
m.setState(Paused)
select {
case <-m.resume:
m.setState(Running)
case <-m.stop:
m.setState(Stopped)
return miningHalted
case <-m.pause:
panic("Miner already paused")
}
case <-m.stop:
m.setState(Stopped)
return miningHalted
case <-m.resume:
panic("Miner already running")
default:
// No state change - keep mining.
}
// Check if we should reset the nonce.
if b.Nonce == math.MaxUint64 {
b.Nonce = 0
}
// Timestamp and increase the nonce.
b.Time = util.UnixNow()
b.Nonce++
}
m.setState(Stopped)
return &MiningResult{
Complete: true,
Info: MiningSuccessful,
}
}
// setState synchronously sets the current state of the miner to the given state.
func (m *Miner) setState(state MinerState) {
m.stateLock.Lock()
defer m.stateLock.Unlock()
m.state = state
}
// StopMining causes the miner to abort the current mining job immediately.
func (m *Miner) StopMining() {
m.stop <- true
}
// PauseIfRunning pauses the current mining job if it is current running. Returns
// true if the miner was running and false otherwise.
func (m *Miner) PauseIfRunning() bool {
m.stateLock.RLock()
defer m.stateLock.RUnlock()
if m.state == Running {
m.pause <- true
return true
}
return false
}
// ResumeMining causes the miner to continue mining from a paused state.
func (m *Miner) ResumeMining() {
m.resume <- true
}
// State synchronously returns the current state of the miner.
func (m *Miner) State() MinerState {
m.stateLock.RLock()
defer m.stateLock.RUnlock()
return m.state
}
// VerifyProofOfWork computes the hash of the MiningHeader and returns true if
// the result is less than the target
func (m *Miner) VerifyProofOfWork(b *blockchain.Block) bool {
return blockchain.HashSum(b).LessThan(b.Target)
}
// CloudBase prepends the cloudbase transaction to the front of a list of
// transactions in a block that is to be added to the blockchain
func CloudBase(
b *blockchain.Block,
bc *blockchain.BlockChain,
cb blockchain.Address) *blockchain.Block {
// Create a cloudbase transaction by setting all inputs to 0
cbInput := blockchain.TxHashPointer{
BlockNumber: 0,
Hash: blockchain.NilHash,
Index: 0,
}
// Set the transaction amount to the BlockReward
// TODO: Add transaction fees
cbReward := blockchain.TxOutput{
Amount: consensus.CurrentBlockReward(bc),
Recipient: cb.Repr(),
}
cbTxBody := blockchain.TxBody{
Sender: blockchain.NilAddr,
Inputs: []blockchain.TxHashPointer{cbInput},
Outputs: []blockchain.TxOutput{cbReward},
}
cbTx := blockchain.Transaction{
TxBody: cbTxBody,
Sig: blockchain.NilSig,
}
b.Transactions = append([]*blockchain.Transaction{&cbTx}, b.Transactions...)
return b
} | miner/miner.go | 0.569613 | 0.417984 | miner.go | starcoder |
package taskmaster
import (
"fmt"
"time"
"github.com/go-ole/go-ole"
"github.com/go-ole/go-ole/oleutil"
"github.com/rickb777/date/period"
)
// AddExecAction adds an execute action to the task definition. The args
// parameter can have up to 32 $(ArgX) values, such as '/c $(Arg0) $(Arg1)'.
// This will allow the arguments to be dynamically entered when the task is run.
func (d *Definition) AddExecAction(path, args, workingDir, id string) {
d.Actions = append(d.Actions, ExecAction{
Path: path,
Args: args,
WorkingDir: workingDir,
TaskAction: TaskAction{
ID: id,
taskActionTypeHolder: taskActionTypeHolder{
actionType: TASK_ACTION_EXEC,
},
},
})
}
// AddComHandlerAction adds a COM handler action to the task definition. The clisd
// parameter is the CLSID of the COM object that will get instantiated when the action
// executes, and the data parameter is the arguments passed to the COM object.
func (d *Definition) AddComHandlerAction(clsid, data, id string) {
d.Actions = append(d.Actions, ComHandlerAction{
ClassID: clsid,
Data: data,
TaskAction: TaskAction{
ID: id,
taskActionTypeHolder: taskActionTypeHolder{
actionType: TASK_ACTION_COM_HANDLER,
},
},
})
}
func (d *Definition) AddBootTrigger(delay period.Period) {
d.AddBootTriggerEx(delay, "", time.Time{}, time.Time{}, period.Period{}, period.Period{}, period.Period{}, false, true)
}
func (d *Definition) AddBootTriggerEx(delay period.Period, id string, startBoundary, endBoundary time.Time, timeLimit, repetitionDuration, repetitionInterval period.Period, stopAtDurationEnd, enabled bool) {
d.Triggers = append(d.Triggers, BootTrigger{
Delay: delay,
TaskTrigger: TaskTrigger{
Enabled: enabled,
EndBoundary: endBoundary,
ExecutionTimeLimit: timeLimit,
ID: id,
RepetitionPattern: RepetitionPattern{
RepetitionDuration: repetitionDuration,
RepetitionInterval: repetitionInterval,
StopAtDurationEnd: stopAtDurationEnd,
},
StartBoundary: startBoundary,
taskTriggerTypeHolder: taskTriggerTypeHolder{
triggerType: TASK_TRIGGER_BOOT,
},
},
})
}
func (d *Definition) AddDailyTrigger(dayInterval DayInterval, randomDelay period.Period, startBoundary time.Time) {
d.AddDailyTriggerEx(dayInterval, randomDelay, "", startBoundary, time.Time{}, period.Period{}, period.Period{}, period.Period{}, false, true)
}
func (d *Definition) AddDailyTriggerEx(dayInterval DayInterval, randomDelay period.Period, id string, startBoundary, endBoundary time.Time, timeLimit, repetitionDuration, repetitionInterval period.Period, stopAtDurationEnd, enabled bool) {
d.Triggers = append(d.Triggers, DailyTrigger{
DayInterval: dayInterval,
RandomDelay: randomDelay,
TaskTrigger: TaskTrigger{
Enabled: enabled,
EndBoundary: endBoundary,
ExecutionTimeLimit: timeLimit,
ID: id,
RepetitionPattern: RepetitionPattern{
RepetitionDuration: repetitionDuration,
RepetitionInterval: repetitionInterval,
StopAtDurationEnd: stopAtDurationEnd,
},
StartBoundary: startBoundary,
taskTriggerTypeHolder: taskTriggerTypeHolder{
triggerType: TASK_TRIGGER_DAILY,
},
},
})
}
func (d *Definition) AddEventTrigger(delay period.Period, subscription string, valueQueries map[string]string) {
d.AddEventTriggerEx(delay, subscription, valueQueries, "", time.Time{}, time.Time{}, period.Period{}, period.Period{}, period.Period{}, false, true)
}
func (d *Definition) AddEventTriggerEx(delay period.Period, subscription string, valueQueries map[string]string, id string, startBoundary, endBoundary time.Time, timeLimit, repetitionDuration, repetitionInterval period.Period, stopAtDurationEnd, enabled bool) {
d.Triggers = append(d.Triggers, EventTrigger{
Delay: delay,
Subscription: subscription,
ValueQueries: valueQueries,
TaskTrigger: TaskTrigger{
Enabled: enabled,
EndBoundary: endBoundary,
ExecutionTimeLimit: timeLimit,
ID: id,
RepetitionPattern: RepetitionPattern{
RepetitionDuration: repetitionDuration,
RepetitionInterval: repetitionInterval,
StopAtDurationEnd: stopAtDurationEnd,
},
StartBoundary: startBoundary,
taskTriggerTypeHolder: taskTriggerTypeHolder{
triggerType: TASK_TRIGGER_EVENT,
},
},
})
}
func (d *Definition) AddIdleTrigger() {
d.AddIdleTriggerEx("", time.Time{}, time.Time{}, period.Period{}, period.Period{}, period.Period{}, false, true)
}
func (d *Definition) AddIdleTriggerEx(id string, startBoundary, endBoundary time.Time, timeLimit, repetitionDuration, repetitionInterval period.Period, stopAtDurationEnd, enabled bool) {
d.Triggers = append(d.Triggers, IdleTrigger{
TaskTrigger: TaskTrigger{
Enabled: enabled,
EndBoundary: endBoundary,
ExecutionTimeLimit: timeLimit,
ID: id,
RepetitionPattern: RepetitionPattern{
RepetitionDuration: repetitionDuration,
RepetitionInterval: repetitionInterval,
StopAtDurationEnd: stopAtDurationEnd,
},
StartBoundary: startBoundary,
taskTriggerTypeHolder: taskTriggerTypeHolder{
triggerType: TASK_TRIGGER_IDLE,
},
},
})
}
func (d *Definition) AddLogonTrigger(delay period.Period, userID string) {
d.AddLogonTriggerEx(delay, userID, "", time.Time{}, time.Time{}, period.Period{}, period.Period{}, period.Period{}, false, true)
}
func (d *Definition) AddLogonTriggerEx(delay period.Period, userID, id string, startBoundary, endBoundary time.Time, timeLimit, repetitionDuration, repetitionInterval period.Period, stopAtDurationEnd, enabled bool) {
d.Triggers = append(d.Triggers, LogonTrigger{
Delay: delay,
UserID: userID,
TaskTrigger: TaskTrigger{
Enabled: enabled,
EndBoundary: endBoundary,
ExecutionTimeLimit: timeLimit,
ID: id,
RepetitionPattern: RepetitionPattern{
RepetitionDuration: repetitionDuration,
RepetitionInterval: repetitionInterval,
StopAtDurationEnd: stopAtDurationEnd,
},
StartBoundary: startBoundary,
taskTriggerTypeHolder: taskTriggerTypeHolder{
triggerType: TASK_TRIGGER_LOGON,
},
},
})
}
func (d *Definition) AddMonthlyDOWTrigger(dayOfWeek Day, weekOfMonth Week, monthOfYear Month, runOnLastWeekOfMonth bool, randomDelay period.Period, startBoundary time.Time) {
d.AddMonthlyDOWTriggerEx(dayOfWeek, weekOfMonth, monthOfYear, runOnLastWeekOfMonth, randomDelay, "", startBoundary, time.Time{}, period.Period{}, period.Period{}, period.Period{}, false, true)
}
func (d *Definition) AddMonthlyDOWTriggerEx(dayOfWeek Day, weekOfMonth Week, monthOfYear Month, runOnLastWeekOfMonth bool, randomDelay period.Period, id string, startBoundary, endBoundary time.Time, timeLimit, repetitionDuration, repetitionInterval period.Period, stopAtDurationEnd, enabled bool) {
d.Triggers = append(d.Triggers, MonthlyDOWTrigger{
DaysOfWeek: dayOfWeek,
MonthsOfYear: monthOfYear,
RandomDelay: randomDelay,
RunOnLastWeekOfMonth: runOnLastWeekOfMonth,
WeeksOfMonth: weekOfMonth,
TaskTrigger: TaskTrigger{
Enabled: enabled,
EndBoundary: endBoundary,
ExecutionTimeLimit: timeLimit,
ID: id,
RepetitionPattern: RepetitionPattern{
RepetitionDuration: repetitionDuration,
RepetitionInterval: repetitionInterval,
StopAtDurationEnd: stopAtDurationEnd,
},
StartBoundary: startBoundary,
taskTriggerTypeHolder: taskTriggerTypeHolder{
triggerType: TASK_TRIGGER_MONTHLYDOW,
},
},
})
}
func (d *Definition) AddMonthlyTrigger(dayOfMonth int, monthOfYear Month, randomDelay period.Period, startBoundary time.Time) {
d.AddMonthlyTriggerEx(dayOfMonth, monthOfYear, randomDelay, "", startBoundary, time.Time{}, period.Period{}, period.Period{}, period.Period{}, false, true)
}
func (d *Definition) AddMonthlyTriggerEx(dayOfMonth int, monthOfYear Month, randomDelay period.Period, id string, startBoundary, endBoundary time.Time, timeLimit, repetitionDuration, repetitionInterval period.Period, stopAtDurationEnd, enabled bool) error {
monthDay, err := IntToDayOfMonth(dayOfMonth)
if err != nil {
return err
}
d.Triggers = append(d.Triggers, MonthlyTrigger{
DaysOfMonth: monthDay,
MonthsOfYear: monthOfYear,
RandomDelay: randomDelay,
TaskTrigger: TaskTrigger{
Enabled: enabled,
EndBoundary: endBoundary,
ExecutionTimeLimit: timeLimit,
ID: id,
RepetitionPattern: RepetitionPattern{
RepetitionDuration: repetitionDuration,
RepetitionInterval: repetitionInterval,
StopAtDurationEnd: stopAtDurationEnd,
},
StartBoundary: startBoundary,
taskTriggerTypeHolder: taskTriggerTypeHolder{
triggerType: TASK_TRIGGER_MONTHLY,
},
},
})
return nil
}
func (d *Definition) AddRegistrationTrigger(delay period.Period) {
d.AddRegistrationTriggerEx(delay, "", time.Time{}, time.Time{}, period.Period{}, period.Period{}, period.Period{}, false, true)
}
func (d *Definition) AddRegistrationTriggerEx(delay period.Period, id string, startBoundary, endBoundary time.Time, timeLimit, repetitionDuration, repetitionInterval period.Period, stopAtDurationEnd, enabled bool) {
d.Triggers = append(d.Triggers, RegistrationTrigger{
Delay: delay,
TaskTrigger: TaskTrigger{
Enabled: enabled,
EndBoundary: endBoundary,
ExecutionTimeLimit: timeLimit,
ID: id,
RepetitionPattern: RepetitionPattern{
RepetitionDuration: repetitionDuration,
RepetitionInterval: repetitionInterval,
StopAtDurationEnd: stopAtDurationEnd,
},
StartBoundary: startBoundary,
taskTriggerTypeHolder: taskTriggerTypeHolder{
triggerType: TASK_TRIGGER_REGISTRATION,
},
},
})
}
func (d *Definition) AddSessionStateChangeTrigger(userID string, stateChange TaskSessionStateChangeType, delay period.Period) {
d.AddSessionStateChangeTriggerEx(userID, stateChange, delay, "", time.Time{}, time.Time{}, period.Period{}, period.Period{}, period.Period{}, false, true)
}
func (d *Definition) AddSessionStateChangeTriggerEx(userID string, stateChange TaskSessionStateChangeType, delay period.Period, id string, startBoundary, endBoundary time.Time, timeLimit, repetitionDuration, repetitionInterval period.Period, stopAtDurationEnd, enabled bool) {
d.Triggers = append(d.Triggers, SessionStateChangeTrigger{
Delay: delay,
StateChange: stateChange,
UserId: userID,
TaskTrigger: TaskTrigger{
Enabled: enabled,
EndBoundary: endBoundary,
ExecutionTimeLimit: timeLimit,
ID: id,
RepetitionPattern: RepetitionPattern{
RepetitionDuration: repetitionDuration,
RepetitionInterval: repetitionInterval,
StopAtDurationEnd: stopAtDurationEnd,
},
StartBoundary: startBoundary,
taskTriggerTypeHolder: taskTriggerTypeHolder{
triggerType: TASK_TRIGGER_SESSION_STATE_CHANGE,
},
},
})
}
func (d *Definition) AddTimeTrigger(randomDelay period.Period, startBoundary time.Time) {
d.AddTimeTriggerEx(randomDelay, "", startBoundary, time.Time{}, period.Period{}, period.Period{}, period.Period{}, false, true)
}
func (d *Definition) AddTimeTriggerEx(randomDelay period.Period, id string, startBoundary, endBoundary time.Time, timeLimit, repetitionDuration, repetitionInterval period.Period, stopAtDurationEnd, enabled bool) {
d.Triggers = append(d.Triggers, TimeTrigger{
RandomDelay: randomDelay,
TaskTrigger: TaskTrigger{
Enabled: enabled,
EndBoundary: endBoundary,
ExecutionTimeLimit: timeLimit,
ID: id,
RepetitionPattern: RepetitionPattern{
RepetitionDuration: repetitionDuration,
RepetitionInterval: repetitionInterval,
StopAtDurationEnd: stopAtDurationEnd,
},
StartBoundary: startBoundary,
taskTriggerTypeHolder: taskTriggerTypeHolder{
triggerType: TASK_TRIGGER_TIME,
},
},
})
}
func (d *Definition) AddWeeklyTrigger(dayOfWeek Day, weekInterval WeekInterval, randomDelay period.Period, startBoundary time.Time) {
d.AddWeeklyTriggerEx(dayOfWeek, weekInterval, randomDelay, "", startBoundary, time.Time{}, period.Period{}, period.Period{}, period.Period{}, false, true)
}
func (d *Definition) AddWeeklyTriggerEx(dayOfWeek Day, weekInterval WeekInterval, randomDelay period.Period, id string, startBoundary, endBoundary time.Time, timeLimit, repetitionDuration, repetitionInterval period.Period, stopAtDurationEnd, enabled bool) {
d.Triggers = append(d.Triggers, WeeklyTrigger{
DaysOfWeek: dayOfWeek,
RandomDelay: randomDelay,
WeekInterval: weekInterval,
TaskTrigger: TaskTrigger{
Enabled: enabled,
EndBoundary: endBoundary,
ExecutionTimeLimit: timeLimit,
ID: id,
RepetitionPattern: RepetitionPattern{
RepetitionDuration: repetitionDuration,
RepetitionInterval: repetitionInterval,
StopAtDurationEnd: stopAtDurationEnd,
},
StartBoundary: startBoundary,
taskTriggerTypeHolder: taskTriggerTypeHolder{
triggerType: TASK_TRIGGER_WEEKLY,
},
},
})
}
// Refresh refreshes all of the local instance variables of the running task.
// https://docs.microsoft.com/en-us/windows/desktop/api/taskschd/nf-taskschd-irunningtask-refresh
func (r RunningTask) Refresh() error {
_, err := oleutil.CallMethod(r.taskObj, "Refresh")
if err != nil {
return fmt.Errorf("error calling Refresh on %s IRunningTask: %s", r.Path, err)
}
return nil
}
// Stop kills and releases a running task.
// https://docs.microsoft.com/en-us/windows/desktop/api/taskschd/nf-taskschd-irunningtask-stop
func (r *RunningTask) Stop() error {
_, err := oleutil.CallMethod(r.taskObj, "Stop")
if err != nil {
return fmt.Errorf("error calling Stop on %s IRunningTask: %s", r.Path, err)
}
r.taskObj.Release()
r.isReleased = true
return nil
}
// Release frees the running task COM object. Must be called before
// program termination to avoid memory leaks.
func (r *RunningTask) Release() {
if !r.isReleased {
r.taskObj.Release()
r.isReleased = true
}
}
// Run starts an instance of a registered task. If the task was started successfully,
// a pointer to a running task will be returned.
// https://docs.microsoft.com/en-us/windows/desktop/api/taskschd/nf-taskschd-iregisteredtask-run
func (r *RegisteredTask) Run(args []string) (*RunningTask, error) {
return r.RunEx(args, TASK_RUN_AS_SELF, 0, "")
}
// RunEx starts an instance of a registered task. If the task was started successfully,
// a pointer to a running task will be returned.
// https://docs.microsoft.com/en-us/windows/desktop/api/taskschd/nf-taskschd-iregisteredtask-runex
func (r *RegisteredTask) RunEx(args []string, flags TaskRunFlags, sessionID int, user string) (*RunningTask, error) {
if !r.Enabled {
return nil, fmt.Errorf("error calling RunEx on %s IRegisteredTask: cannot run a disabled task", r.Path)
}
runningTaskObj, err := oleutil.CallMethod(r.taskObj, "RunEx", args, int(flags), sessionID, user)
if err != nil {
return nil, fmt.Errorf("error calling RunEx on %s IRegisteredTask: %s", r.Path, err)
}
runningTask := parseRunningTask(runningTaskObj.ToIDispatch())
return runningTask, nil
}
// GetInstances returns all of the currently running instances of a registered task.
// The returned slice may contain nil entries if tasks are stopped while they are being parsed.
// https://docs.microsoft.com/en-us/windows/desktop/api/taskschd/nf-taskschd-iregisteredtask-getinstances
func (r *RegisteredTask) GetInstances() ([]*RunningTask, error) {
runningTasks, err := oleutil.CallMethod(r.taskObj, "GetInstances", 0)
if err != nil {
return nil, fmt.Errorf("error calling GetInstances on %s IRegisteredTask: %s", r.Path, err)
}
runningTasksObj := runningTasks.ToIDispatch()
defer runningTasksObj.Release()
var parsedRunningTasks []*RunningTask
oleutil.ForEach(runningTasksObj, func(v *ole.VARIANT) error {
runningTaskObj := v.ToIDispatch()
parsedRunningTask := parseRunningTask(runningTaskObj)
parsedRunningTasks = append(parsedRunningTasks, parsedRunningTask)
return nil
})
return parsedRunningTasks, nil
}
// Stop kills all running instances of the registered task that the current
// user has access to. If all instances were killed, Stop returns true,
// otherwise Stop returns false.
// https://docs.microsoft.com/en-us/windows/desktop/api/taskschd/nf-taskschd-iregisteredtask-stop
func (r *RegisteredTask) Stop() bool {
ret, _ := oleutil.CallMethod(r.taskObj, "Stop", 0)
if ret.Val != 0 {
return false
}
return true
} | tasks.go | 0.643329 | 0.426441 | tasks.go | starcoder |
package main
import (
"bufio"
"fmt"
"os"
"time"
// My packages
"github.com/rsdoiel/stngo"
// Caltech Library packages
"github.com/caltechlibrary/cli"
)
var (
synopsis = `
%s a standard timesheet notation filter.
`
description = `
%s will filter the output from stnparse based on date or matching text.
`
examples = `
Filter TimeSheet.tab from July 4, 2015 through July 14, 2015
and render a stream of JSON blobs.
` + "```" + `
%s -start 2015-07-04 -end 2015-07-14 -json < TimeSheet.tab
` + "```" + `
To render the same in a tab delimited output
` + "```" + `
%s -start 2015-07-04 -end 2015-07-14 < TimeSheet.tab
` + "```" + `
Typical usage would be in a pipeline with Unix cat and stnparse
` + "```" + `
cat Time_Sheet.txt | stnparse | %s -start 2015-07-06 -end 2015-07-010
` + "```" + `
Matching a project name "Fred" for the same week would look like
` + "```" + `
cat Time_Sheet.txt | stnparse | %s -start 2015-07-06 -end 2015-07-010 -match Fred
` + "```" + `
`
// Standard Options
showHelp bool
showLicense bool
showVersion bool
showExamples bool
inputFName string
outputFName string
quiet bool
generateMarkdown bool
generateManPage bool
// App Options
start string
end string
match string
asJSON bool
)
func main() {
// Configuration and command line interation
app := cli.NewCli(stn.Version)
appName := app.AppName()
// Add some Help docs
app.AddHelp("license", []byte(fmt.Sprintf(stn.LicenseText, appName, stn.Version)))
app.AddHelp("synopsis", []byte(fmt.Sprintf(synopsis, appName)))
app.AddHelp("description", []byte(fmt.Sprintf(description, appName)))
app.AddHelp("examples", []byte(fmt.Sprintf(examples, appName, appName, appName, appName)))
// Standard Options
app.BoolVar(&showHelp, "h,help", false, "display help")
app.BoolVar(&showLicense, "l,license", false, "display license")
app.BoolVar(&showVersion, "v,version", false, "display version")
app.BoolVar(&showExamples, "examples", false, "display examples(s)")
app.StringVar(&inputFName, "i,input", "", "input file name")
app.StringVar(&outputFName, "o,output", "", "output file name")
app.BoolVar(&quiet, "quiet", false, "suppress error message")
app.BoolVar(&generateMarkdown, "generate-markdown", false, "generate markdown documentation")
app.BoolVar(&generateManPage, "generate-manpage", false, "generate man page")
// App Options
app.StringVar(&match, "m,match", "", "Match text annotations")
app.StringVar(&start, "s,start", "", "start of inclusive date range")
app.StringVar(&end, "e,end", "", "end of inclusive date range")
app.BoolVar(&asJSON, "j,json", false, "output JSON format")
// Run the command line interface
app.Parse()
args := app.Args()
// Setup IO
var err error
app.Eout = os.Stderr
app.In, err = cli.Open(inputFName, os.Stdin)
cli.ExitOnError(app.Eout, err, quiet)
defer cli.CloseFile(inputFName, app.In)
app.Out, err = cli.Create(outputFName, os.Stdout)
cli.ExitOnError(app.Eout, err, quiet)
defer cli.CloseFile(outputFName, app.Out)
// Handle Options
if generateMarkdown {
app.GenerateMarkdown(app.Out)
os.Exit(0)
}
if generateManPage {
app.GenerateManPage(app.Out)
os.Exit(0)
}
if showHelp || showExamples {
if len(args) > 0 {
fmt.Fprintln(app.Out, app.Help(args...))
} else if showExamples {
fmt.Fprintln(app.Out, app.Help("examples"))
} else {
app.Usage(app.Out)
}
os.Exit(0)
}
if showLicense {
fmt.Fprintln(app.Out, app.License())
os.Exit(0)
}
if showVersion {
fmt.Fprintln(app.Out, app.Version())
os.Exit(0)
}
// On to running the app
var (
showLine = true
startTime time.Time
endTime time.Time
activeDate time.Time
)
activeDate = time.Now()
if start != "" {
startTime, err = time.Parse("2006-01-02 15:04:05", start+" 00:00:00")
if err != nil {
fmt.Fprintf(app.Eout, "Start date error: %s\n", err)
os.Exit(1)
}
if end == "" {
endTime = activeDate
} else {
endTime, err = time.Parse("2006-01-02 15:04:05", end+" 23:59:59")
if err != nil {
fmt.Fprintf(app.Eout, "End date error: %s\n", err)
os.Exit(1)
}
}
}
reader := bufio.NewReader(app.In)
entry := new(stn.Entry)
lineNo := 0
for {
showLine = true
line, err := reader.ReadString('\n')
if err != nil {
break
}
lineNo++
if entry.FromString(line) != true {
fmt.Fprintf(app.Eout, "line no. %d: can't filter [%s]\n", lineNo, line)
os.Exit(1)
}
if start != "" {
showLine = entry.IsInRange(startTime, endTime)
}
if showLine == true && match != "" {
showLine = entry.IsMatch(match)
}
if showLine == true {
fmt.Fprintf(app.Out, "%s", line)
}
}
} | cmd/stnfilter/stnfilter.go | 0.576304 | 0.592814 | stnfilter.go | starcoder |
package util
import (
"fmt"
bot "github.com/Tnze/gomcbot"
"math"
"time"
)
// TweenLookAt is the Tween version of LookAt
func TweenLookAt(g *bot.Game, x, y, z float64, t time.Duration) {
p := g.GetPlayer()
x0, y0, z0 := p.GetPosition()
x, y, z = x-x0, y-y0, z-z0
r := math.Sqrt(x*x + y*y + z*z)
yaw := -math.Atan2(x, z) / math.Pi * 180
for yaw < 0 {
yaw = 360 + yaw
}
pitch := -math.Asin(y/r) / math.Pi * 180
TweenLook(g, float32(yaw), float32(pitch), t)
}
// TweenLook do tween animation at player's head.
func TweenLook(g *bot.Game, yaw, pitch float32, t time.Duration) {
p := g.GetPlayer()
start := time.Now()
yaw0, pitch0 := p.Yaw, p.Pitch
ofstY, ofstP := yaw-yaw0, pitch-pitch0
var scale float32
for scale < 1 {
scale = float32(time.Since(start)) / float32(t)
g.LookYawPitch(yaw0+ofstY*scale, pitch0+ofstP*scale)
time.Sleep(time.Millisecond * 50)
}
}
//TweenLineMove allows you smoothly move on plane. You can't move in Y axis
func TweenLineMove(g *bot.Game, x, z float64) error {
p := g.GetPlayer()
start := time.Now()
x0, y0, z0 := p.GetPosition()
if similar(x0, x) && similar(z0, z) {
return nil
}
y0 = math.Floor(y0)
ofstX, ofstZ := x-x0, z-z0
t := time.Duration(float64(time.Second) * (math.Sqrt(ofstX*ofstX+ofstZ*ofstZ) / 4.2))
var scale float64
for scale < 1 {
scale = float64(time.Since(start)) / float64(t)
g.SetPosition(x0+ofstX*scale, y0, z0+ofstZ*scale, true)
time.Sleep(time.Millisecond * 50)
}
p = g.GetPlayer()
if !similar(p.X, x) || !similar(p.Z, z) {
return fmt.Errorf("wrongly move")
}
return nil
}
func similar(a, b float64) bool {
return a-b < 1 && b-a < 1
}
//TweenJump simulate player jump make no headway
func TweenJump(g *bot.Game) {
p := g.GetPlayer()
y := math.Floor(p.Y)
for tick := 0; tick < 11; tick++ {
h := -1.7251e-8 + 0.4591*float64(tick) - 0.0417*float64(tick)*float64(tick)
g.SetPosition(p.X, y+h, p.Z, false)
time.Sleep(time.Millisecond * 50)
}
g.SetPosition(p.X, p.Y, p.Z, true)
}
//TweenJumpTo simulate player jump up a block
func TweenJumpTo(g *bot.Game, x, z int) {
p := g.GetPlayer()
y := math.Floor(p.Y)
for tick := 0; tick < 7; tick++ {
h := -1.7251e-8 + 0.4591*float64(tick) - 0.0417*float64(tick)*float64(tick)
g.SetPosition(p.X, y+h, p.Z, false)
time.Sleep(time.Millisecond * 50)
}
TweenLineMove(g, float64(x)+0.5, float64(z)+0.5)
CalibratePos(g)
} | util/tween.go | 0.743727 | 0.430985 | tween.go | starcoder |
package kasclient
import (
"encoding/json"
)
// InstantQuery struct for InstantQuery
type InstantQuery struct {
Metric *map[string]string `json:"metric,omitempty"`
Timestamp *int64 `json:"Timestamp,omitempty"`
Value float64 `json:"Value"`
}
// NewInstantQuery instantiates a new InstantQuery object
// This constructor will assign default values to properties that have it defined,
// and makes sure properties required by API are set, but the set of arguments
// will change when the set of required properties is changed
func NewInstantQuery(value float64) *InstantQuery {
this := InstantQuery{}
this.Value = value
return &this
}
// NewInstantQueryWithDefaults instantiates a new InstantQuery object
// This constructor will only assign default values to properties that have it defined,
// but it doesn't guarantee that properties required by API are set
func NewInstantQueryWithDefaults() *InstantQuery {
this := InstantQuery{}
return &this
}
// GetMetric returns the Metric field value if set, zero value otherwise.
func (o *InstantQuery) GetMetric() map[string]string {
if o == nil || o.Metric == nil {
var ret map[string]string
return ret
}
return *o.Metric
}
// GetMetricOk returns a tuple with the Metric field value if set, nil otherwise
// and a boolean to check if the value has been set.
func (o *InstantQuery) GetMetricOk() (*map[string]string, bool) {
if o == nil || o.Metric == nil {
return nil, false
}
return o.Metric, true
}
// HasMetric returns a boolean if a field has been set.
func (o *InstantQuery) HasMetric() bool {
if o != nil && o.Metric != nil {
return true
}
return false
}
// SetMetric gets a reference to the given map[string]string and assigns it to the Metric field.
func (o *InstantQuery) SetMetric(v map[string]string) {
o.Metric = &v
}
// GetTimestamp returns the Timestamp field value if set, zero value otherwise.
func (o *InstantQuery) GetTimestamp() int64 {
if o == nil || o.Timestamp == nil {
var ret int64
return ret
}
return *o.Timestamp
}
// GetTimestampOk returns a tuple with the Timestamp field value if set, nil otherwise
// and a boolean to check if the value has been set.
func (o *InstantQuery) GetTimestampOk() (*int64, bool) {
if o == nil || o.Timestamp == nil {
return nil, false
}
return o.Timestamp, true
}
// HasTimestamp returns a boolean if a field has been set.
func (o *InstantQuery) HasTimestamp() bool {
if o != nil && o.Timestamp != nil {
return true
}
return false
}
// SetTimestamp gets a reference to the given int64 and assigns it to the Timestamp field.
func (o *InstantQuery) SetTimestamp(v int64) {
o.Timestamp = &v
}
// GetValue returns the Value field value
func (o *InstantQuery) GetValue() float64 {
if o == nil {
var ret float64
return ret
}
return o.Value
}
// GetValueOk returns a tuple with the Value field value
// and a boolean to check if the value has been set.
func (o *InstantQuery) GetValueOk() (*float64, bool) {
if o == nil {
return nil, false
}
return &o.Value, true
}
// SetValue sets field value
func (o *InstantQuery) SetValue(v float64) {
o.Value = v
}
func (o InstantQuery) MarshalJSON() ([]byte, error) {
toSerialize := map[string]interface{}{}
if o.Metric != nil {
toSerialize["metric"] = o.Metric
}
if o.Timestamp != nil {
toSerialize["Timestamp"] = o.Timestamp
}
if true {
toSerialize["Value"] = o.Value
}
return json.Marshal(toSerialize)
}
type NullableInstantQuery struct {
value *InstantQuery
isSet bool
}
func (v NullableInstantQuery) Get() *InstantQuery {
return v.value
}
func (v *NullableInstantQuery) Set(val *InstantQuery) {
v.value = val
v.isSet = true
}
func (v NullableInstantQuery) IsSet() bool {
return v.isSet
}
func (v *NullableInstantQuery) Unset() {
v.value = nil
v.isSet = false
}
func NewNullableInstantQuery(val *InstantQuery) *NullableInstantQuery {
return &NullableInstantQuery{value: val, isSet: true}
}
func (v NullableInstantQuery) MarshalJSON() ([]byte, error) {
return json.Marshal(v.value)
}
func (v *NullableInstantQuery) UnmarshalJSON(src []byte) error {
v.isSet = true
return json.Unmarshal(src, &v.value)
} | pkg/api/kas/client/model_instant_query.go | 0.785391 | 0.405655 | model_instant_query.go | starcoder |
package strings
import (
"errors"
"fmt"
"reflect"
"regexp"
"strings"
"text/template"
"time"
"unicode"
"unicode/utf8"
"github.com/mantidtech/tplr/functions/helper"
"github.com/mantidtech/wordcase"
)
// Functions that primarily operate on strings
func Functions() template.FuncMap {
return template.FuncMap{
"bracket": Bracket,
"bracketWith": BracketWith,
"camelCase": wordcase.CamelCase,
"dotCase": wordcase.DotCase,
"indent": Indent,
"tabIndent": TabIndent,
"unindent": Unindent,
"kebabCase": wordcase.KebabCase,
"nl": Newline,
"now": Now,
"padLeft": PadLeft,
"padRight": PadRight,
"pascalCase": wordcase.PascalCase,
"prefix": Prefix,
"q": QuoteSingle,
"qq": QuoteDouble,
"qb": QuoteBack,
"rep": Rep,
"screamingSnakeCase": wordcase.ScreamingSnakeCase,
"snakeCase": wordcase.SnakeCase,
"sp": Space,
"space": Space,
"splitOn": SplitOn,
"suffix": Suffix,
"tab": Tab,
"titleCase": wordcase.TitleCase,
"titleCaseWithAbbr": TitleCaseWithAbbr,
"toColumns": ToColumn,
"toLower": strings.ToLower,
"toUpper": strings.ToUpper,
"toWords": wordcase.Words,
"trim": strings.TrimSpace,
"typeKind": TypeKind,
"typeName": TypeName,
"ucFirst": UppercaseFirst,
}
}
// titleCaseWithAbbrHelper converts the first letter of each word to uppercase, or the whole word if it matches a given abbreviation
func titleCaseWithAbbrHelper(abbrev []string) wordcase.Combiner {
selector := wordcase.KeyWordFn(abbrev)
return wordcase.NewPipeline().
TokenizeUsing(wordcase.LookAroundCategorizer, wordcase.NotLetterOrDigit, true).
TokenizeUsing(wordcase.LookAroundCategorizer, wordcase.NotLowerOrDigit, false).
WithAllFormatter(strings.ToLower).
WithFormatter(strings.ToUpper, selector).
WithAllFormatter(wordcase.UppercaseFirst).
JoinWith(" ")
}
// TitleCaseWithAbbr upper-cases the first letter of each word, or the whole word if it matches a given abbreviation
func TitleCaseWithAbbr(abbrev interface{}, word string) (string, error) {
a, l, err := helper.ListInfo(abbrev)
if err != nil {
return "", err
}
strList := make([]string, l)
for c := 0; c < l; c++ {
strList[c] = fmt.Sprintf("%v", a.Index(c).Interface())
}
tc := titleCaseWithAbbrHelper(strList)
return tc(word), nil
}
// UppercaseFirst converts the first character in a string to uppercase
func UppercaseFirst(s interface{}) string {
str := fmt.Sprintf("%v", s)
if str == "" {
return ""
}
r, n := utf8.DecodeRuneInString(str)
return string(unicode.ToUpper(r)) + str[n:]
}
// Space prints a space character the given number of times
func Space(n int) string {
if n < 0 {
return ""
}
return strings.Repeat(" ", n)
}
// Tab prints a tab character the given number of times
func Tab(n int) string {
if n < 0 {
return ""
}
return strings.Repeat("\t", n)
}
// PadRight prints the given string in the given number of columns, right aligned
func PadRight(n int, s interface{}) string {
f := fmt.Sprintf("%%-%dv", n)
return fmt.Sprintf(f, s)
}
// PadLeft prints the given string in the given number of columns, left aligned
func PadLeft(n int, s interface{}) string {
f := fmt.Sprintf("%%%dv", n)
return fmt.Sprintf(f, s)
}
// Bracket adds brackets around the given string
func Bracket(item interface{}) string {
return fmt.Sprintf("(%v)", item)
}
// QuoteSingle adds single quote around the given string
func QuoteSingle(item interface{}) string {
return fmt.Sprintf("'%v'", item)
}
// QuoteDouble adds double quote around the given string
func QuoteDouble(item interface{}) string {
return fmt.Sprintf("\"%v\"", item)
}
// QuoteBack adds back-quotes around the given string
func QuoteBack(item interface{}) string {
return fmt.Sprintf("`%v`", item)
}
// BracketWith adds brackets of a given type around the given string
func BracketWith(bracketPair string, item interface{}) (string, error) {
if len(bracketPair)%2 != 0 {
return "", fmt.Errorf("expected a set of brackets with matching left and right sizes")
}
h := len(bracketPair) / 2
l, r := bracketPair[:h], bracketPair[h:]
return fmt.Sprintf("%s%v%s", l, item, r), nil
}
// Newline prints a newline (handy for trying to format templates)
func Newline(count ...int) string {
if len(count) == 0 {
return "\n"
}
return strings.Repeat("\n", count[0])
}
// Rep repeats the given string(s) the given number of times
func Rep(count int, item ...string) string {
if count < 0 {
return ""
}
r := strings.Join(item, " ")
return strings.Repeat(r, count)
}
// Indent prints the given string with the given number of spaces prepended before each line
func Indent(count int, content string) string {
return Prefix(" ", count, content)
}
// TabIndent prints the given string with the given number of spaces prepended before each line
func TabIndent(count int, content string) string {
return Prefix("\t", count, content)
}
// Unindent removes up to 'count' spaces from the start of all lines within 'content'
func Unindent(count int, content string) (string, error) {
if count == 0 {
return content, nil
} else if count < 0 {
return "", errors.New("cannot unindent by an negative amount")
}
parts := strings.Split(content, "\n")
re := fmt.Sprintf("^\\s{1,%d}", count)
matcher := regexp.MustCompile(re)
for i, p := range parts {
parts[i] = matcher.ReplaceAllString(p, "")
}
return strings.Join(parts, "\n"), nil
}
// Prefix prints the given string with the given number of 'prefix' prepended before each line
func Prefix(prefix string, count int, content string) string {
if count < 0 {
return ""
}
parts := strings.Split(content, "\n")
tab := strings.Repeat(prefix, count)
newParts := make([]string, len(parts))
for i, p := range parts {
if p != "" {
newParts[i] = tab + p
}
}
return strings.Join(newParts, "\n")
}
// Suffix prints the given string with the given number of 'suffix' appended to each line
func Suffix(suffix string, count int, content string) string {
if count < 0 {
return ""
}
parts := strings.Split(content, "\n")
tab := strings.Repeat(suffix, count)
newParts := make([]string, len(parts))
for i, p := range parts {
if p != "" {
newParts[i] = p + tab
}
}
return strings.Join(newParts, "\n")
}
// ToColumn formats the given text to not take more than 'w' characters per line,
// splitting on the space before the word that would take the line over.
// If no space can be found, the line isn't split (ie words bigger than the line size are printed unsplit)
func ToColumn(width int, content string) string {
var b strings.Builder
tail := ""
parts := strings.Split(content, "\n")
for _, p := range parts {
str := tail + p
tail = ""
lines := columnify(width, str)
if len(lines) > 1 {
tail = lines[len(lines)-1]
}
numLines := len(lines)
for i, l := range lines {
if i > 0 && i == numLines-1 {
tail = l
break
}
b.WriteString(l)
b.WriteByte('\n')
}
}
if len(tail) > 0 {
b.WriteString(tail)
b.WriteByte('\n')
}
return b.String()
}
// columnify is a helper method for ToColumn to split lines on spaces
func columnify(w int, s string) []string {
var lines []string
var at, i int
for at < len(s) {
i = at + w
if i >= len(s) {
lines = append(lines, s[at:])
break
}
// look backwards for a space
for ; i > at && s[i] != ' '; i-- {
// just keep stepping
}
if i == at { // didn't find one
// look forwards for a space
for i = at + w; i < len(s) && s[i] != ' '; i++ {
// just keep stepping
}
}
lines = append(lines, s[at:i])
at = i + 1
}
return lines
}
var nowActual = time.Now // use an alias, so we can redefine it in testing
// Now returns the current time in the format "2006-01-02T15:04:05Z07:00"
func Now(format ...string) string {
f := time.RFC3339
if len(format) > 0 {
f = format[0]
}
return nowActual().Format(f)
}
// SplitOn creates an array from the given string by separating it by the glue string
func SplitOn(glue string, content string) []string {
return strings.Split(content, glue)
}
// TypeName returns the type of the given value as a string
func TypeName(value interface{}) string {
if value == nil {
return "nil"
}
return reflect.TypeOf(value).String()
}
// TypeKind returns the 'kind'' of the given value as a string
func TypeKind(value interface{}) string {
if value == nil {
return "nil"
}
return reflect.ValueOf(value).Kind().String()
} | functions/strings/strings.go | 0.615781 | 0.448607 | strings.go | starcoder |
package selector
import "fmt"
type Operator string
const (
// doubleEqualSignOpeator represents ==
DoubleEqualSignOperator Operator = "=="
// notEqualOperator represents !=
NotEqualOperator Operator = "!="
// inOperator represents in
InOperator Operator = "in"
// notInOperator represents notin
NotInOperator Operator = "notin"
// matchesOperator represents matches
MatchesOperator Operator = "matches"
)
type OperationType int
const (
OperationTypeFieldSelector OperationType = 0
OperationTypeLabelSelector OperationType = 1
)
// parser evaluates the tokens produced by the lexer from the input string
type parser struct {
lexer *lexer
position int
results []Token
}
// Operation represents a computation, operation, on an LValue and a set of
// RValues.
type Operation struct {
LValue string
Operator Operator
RValues []string
OperationType OperationType
}
// Parse is deprecated. Use ParseFieldSelector or ParseLabelSelector.
func Parse(input string) (*Selector, error) {
parser := &parser{lexer: newLexer(input)}
parser.tokenize()
operations, err := parser.operations()
if err != nil {
return nil, err
}
selector := &Selector{Operations: operations}
return selector, nil
}
// ParseFieldSelector parses the input and returns a field selector.
func ParseFieldSelector(input string) (*Selector, error) {
sel, err := Parse(input)
if err != nil {
return nil, err
}
for i := range sel.Operations {
sel.Operations[i].OperationType = OperationTypeFieldSelector
}
return sel, nil
}
// ParseLabelSelector parses the input and returns a label selector.
func ParseLabelSelector(input string) (*Selector, error) {
sel, err := Parse(input)
if err != nil {
return nil, err
}
for i := range sel.Operations {
sel.Operations[i].OperationType = OperationTypeLabelSelector
}
return sel, nil
}
// backtrack returns the position to its original place before the last read
// occurred
func (p *parser) backtrack() {
if p.position >= 1 {
p.position--
} else {
p.position = 0
}
}
func (p *parser) parseOperator() (Operator, error) {
result := p.read()
switch result.Type {
case doubleEqualSignToken:
return DoubleEqualSignOperator, nil
case notEqualToken:
return NotEqualOperator, nil
case inToken:
return InOperator, nil
case notInToken:
return NotInOperator, nil
case matchesToken:
return MatchesOperator, nil
default:
return "", fmt.Errorf("unexpected operator '%s' found", result.Value)
}
}
// parseOperation analyzes the next results to determine the next operation
func (p *parser) parseOperation() (Operation, error) {
var r Operation
// First identify the key
result := p.read()
r.LValue = result.Value
// Now identify the operator
var err error
r.Operator, err = p.parseOperator()
if err != nil {
return r, err
}
// Finally, identify the value
switch r.Operator {
case InOperator, NotInOperator:
r.RValues, err = p.parseValues()
if err != nil {
return r, err
}
default:
result := p.read()
switch result.Type {
case identifierToken, stringToken, boolToken, matchesToken:
r.RValues = []string{result.Value}
default:
return r, fmt.Errorf("unexpected token '%s': expected an identifier or literal value", result.Value)
}
}
return r, nil
}
// parseValues parses values found in an array used by the 'in' & 'notin'
// operators, e.g. (a,b,c)
func (p *parser) parseValues() ([]string, error) {
var values []string
// The first token should be '[' or a selector
result := p.read()
if result.Type == identifierToken {
return []string{result.Value}, nil
}
if result.Type != leftSquareToken {
return values, fmt.Errorf("found '%s', expected '['", result.Value)
}
for {
result = p.read()
switch result.Type {
case identifierToken, stringToken:
values = append(values, result.Value)
case commaToken:
continue
case rightSquareToken:
return values, nil
default:
return values, fmt.Errorf("unexpected token '%s', expected a comma or an identifier", result.Value)
}
}
}
// peek returns the next result (token and its concrete value) without consuming
// it by not moving the position
func (p *parser) peek() Token {
defer p.backtrack()
return p.read()
}
// read returns the next rune in the input and consumes it by moving the
// position
func (p *parser) read() Token {
p.position++
return p.results[p.position-1]
}
// operations analyzes the results and determines the list of operations
func (p *parser) operations() ([]Operation, error) {
var operations []Operation
for {
result := p.peek()
switch result.Type {
case identifierToken, stringToken:
operation, err := p.parseOperation()
if err != nil {
return nil, fmt.Errorf("could not parse the operations: %s", err)
}
// We found a valid operation, append it to our list of operations
operations = append(operations, operation)
case doubleAmpersandToken:
// Move the position forward
_ = p.read()
// Make sure we already have a operation before accepting the '&&'
// operator
if len(operations) == 0 {
return operations, fmt.Errorf("unexpected '&&' operator found, expected a operation first")
}
// Make sure the next token is an identifier or a string, which are
// the 2 types of tokens that can start a new expression.
result = p.peek()
if result.Type == identifierToken || result.Type == stringToken {
continue
} else {
return nil, fmt.Errorf("unexpected token '%s', expected an identifier or string after '&&'", result.Value)
}
case endOfStringToken:
return operations, nil
default:
return nil, fmt.Errorf("unexpected token '%s', expected an identifier or end of string", result.Value)
}
}
}
// tokenize goes through the input string and produces a list of tokens stored
// into the results attribute
func (p *parser) tokenize() {
var token Token
for token.Type != endOfStringToken {
token = p.lexer.Tokenize()
p.results = append(p.results, token)
}
} | backend/selector/parser.go | 0.750553 | 0.430207 | parser.go | starcoder |
package ssa
import (
"github.com/pgavlin/gc/src"
"fmt"
)
type lineRange struct {
first, last uint32
}
// An xposmap is a map from fileindex and line of src.XPos to int32,
// implemented sparsely to save space (column and statement status are ignored).
// The sparse skeleton is constructed once, and then reused by ssa phases
// that (re)move values with statements attached.
type xposmap struct {
// A map from file index to maps from line range to integers (block numbers)
maps map[int32]*biasedSparseMap
// The next two fields provide a single-item cache for common case of repeated lines from same file.
lastIndex int32 // -1 means no entry in cache
lastMap *biasedSparseMap // map found at maps[lastIndex]
}
// newXposmap constructs an xposmap valid for inputs which have a file index in the keys of x,
// and line numbers in the range x[file index].
// The resulting xposmap will panic if a caller attempts to set or add an XPos not in that range.
func newXposmap(x map[int]lineRange) *xposmap {
maps := make(map[int32]*biasedSparseMap)
for i, p := range x {
maps[int32(i)] = newBiasedSparseMap(int(p.first), int(p.last))
}
return &xposmap{maps: maps, lastIndex: -1} // zero for the rest is okay
}
// clear removes data from the map but leaves the sparse skeleton.
func (m *xposmap) clear() {
for _, l := range m.maps {
if l != nil {
l.clear()
}
}
m.lastIndex = -1
m.lastMap = nil
}
// mapFor returns the line range map for a given file index.
func (m *xposmap) mapFor(index int32) *biasedSparseMap {
if index == m.lastIndex {
return m.lastMap
}
mf := m.maps[index]
m.lastIndex = index
m.lastMap = mf
return mf
}
// set inserts p->v into the map.
// If p does not fall within the set of fileindex->lineRange used to construct m, this will panic.
func (m *xposmap) set(p src.XPos, v int32) {
s := m.mapFor(p.FileIndex())
if s == nil {
panic(fmt.Sprintf("xposmap.set(%d), file index not found in map\n", p.FileIndex()))
}
s.set(p.Line(), v)
}
// get returns the int32 associated with the file index and line of p.
func (m *xposmap) get(p src.XPos) int32 {
s := m.mapFor(p.FileIndex())
if s == nil {
return -1
}
return s.get(p.Line())
}
// add adds p to m, treating m as a set instead of as a map.
// If p does not fall within the set of fileindex->lineRange used to construct m, this will panic.
// Use clear() in between set/map interpretations of m.
func (m *xposmap) add(p src.XPos) {
m.set(p, 0)
}
// contains returns whether the file index and line of p are in m,
// treating m as a set instead of as a map.
func (m *xposmap) contains(p src.XPos) bool {
s := m.mapFor(p.FileIndex())
if s == nil {
return false
}
return s.contains(p.Line())
}
// remove removes the file index and line for p from m,
// whether m is currently treated as a map or set.
func (m *xposmap) remove(p src.XPos) {
s := m.mapFor(p.FileIndex())
if s == nil {
return
}
s.remove(p.Line())
}
// foreachEntry applies f to each (fileindex, line, value) triple in m.
func (m *xposmap) foreachEntry(f func(j int32, l uint, v int32)) {
for j, mm := range m.maps {
s := mm.size()
for i := 0; i < s; i++ {
l, v := mm.getEntry(i)
f(j, l, v)
}
}
} | compile/ssa/xposmap.go | 0.637708 | 0.550305 | xposmap.go | starcoder |
package ent
import (
"fmt"
"opencensus/core/ent/bedrecord"
"strings"
"time"
"entgo.io/ent/dialect/sql"
)
// BedRecord is the model entity for the BedRecord schema.
type BedRecord struct {
config `json:"-"`
// ID of the ent.
ID int `json:"id,omitempty"`
// ReportedDate holds the value of the "reportedDate" field.
ReportedDate time.Time `json:"reportedDate,omitempty"`
// CollectedDate holds the value of the "collectedDate" field.
CollectedDate time.Time `json:"collectedDate,omitempty"`
// BusyBeds holds the value of the "busyBeds" field.
BusyBeds int `json:"busyBeds,omitempty"`
// AvailableBeds holds the value of the "availableBeds" field.
AvailableBeds int `json:"availableBeds,omitempty"`
// TotalBeds holds the value of the "totalBeds" field.
TotalBeds int `json:"totalBeds,omitempty"`
// KindBed holds the value of the "kindBed" field.
KindBed string `json:"kindBed,omitempty"`
// KindAge holds the value of the "kindAge" field.
KindAge string `json:"kindAge,omitempty"`
// Edges holds the relations/edges for other nodes in the graph.
// The values are being populated by the BedRecordQuery when eager-loading is set.
Edges BedRecordEdges `json:"edges"`
}
// BedRecordEdges holds the relations/edges for other nodes in the graph.
type BedRecordEdges struct {
// Places holds the value of the places edge.
Places []*Place `json:"places,omitempty"`
// loadedTypes holds the information for reporting if a
// type was loaded (or requested) in eager-loading or not.
loadedTypes [1]bool
}
// PlacesOrErr returns the Places value or an error if the edge
// was not loaded in eager-loading.
func (e BedRecordEdges) PlacesOrErr() ([]*Place, error) {
if e.loadedTypes[0] {
return e.Places, nil
}
return nil, &NotLoadedError{edge: "places"}
}
// scanValues returns the types for scanning values from sql.Rows.
func (*BedRecord) scanValues(columns []string) ([]interface{}, error) {
values := make([]interface{}, len(columns))
for i := range columns {
switch columns[i] {
case bedrecord.FieldID, bedrecord.FieldBusyBeds, bedrecord.FieldAvailableBeds, bedrecord.FieldTotalBeds:
values[i] = &sql.NullInt64{}
case bedrecord.FieldKindBed, bedrecord.FieldKindAge:
values[i] = &sql.NullString{}
case bedrecord.FieldReportedDate, bedrecord.FieldCollectedDate:
values[i] = &sql.NullTime{}
default:
return nil, fmt.Errorf("unexpected column %q for type BedRecord", columns[i])
}
}
return values, nil
}
// assignValues assigns the values that were returned from sql.Rows (after scanning)
// to the BedRecord fields.
func (br *BedRecord) assignValues(columns []string, values []interface{}) error {
if m, n := len(values), len(columns); m < n {
return fmt.Errorf("mismatch number of scan values: %d != %d", m, n)
}
for i := range columns {
switch columns[i] {
case bedrecord.FieldID:
value, ok := values[i].(*sql.NullInt64)
if !ok {
return fmt.Errorf("unexpected type %T for field id", value)
}
br.ID = int(value.Int64)
case bedrecord.FieldReportedDate:
if value, ok := values[i].(*sql.NullTime); !ok {
return fmt.Errorf("unexpected type %T for field reportedDate", values[i])
} else if value.Valid {
br.ReportedDate = value.Time
}
case bedrecord.FieldCollectedDate:
if value, ok := values[i].(*sql.NullTime); !ok {
return fmt.Errorf("unexpected type %T for field collectedDate", values[i])
} else if value.Valid {
br.CollectedDate = value.Time
}
case bedrecord.FieldBusyBeds:
if value, ok := values[i].(*sql.NullInt64); !ok {
return fmt.Errorf("unexpected type %T for field busyBeds", values[i])
} else if value.Valid {
br.BusyBeds = int(value.Int64)
}
case bedrecord.FieldAvailableBeds:
if value, ok := values[i].(*sql.NullInt64); !ok {
return fmt.Errorf("unexpected type %T for field availableBeds", values[i])
} else if value.Valid {
br.AvailableBeds = int(value.Int64)
}
case bedrecord.FieldTotalBeds:
if value, ok := values[i].(*sql.NullInt64); !ok {
return fmt.Errorf("unexpected type %T for field totalBeds", values[i])
} else if value.Valid {
br.TotalBeds = int(value.Int64)
}
case bedrecord.FieldKindBed:
if value, ok := values[i].(*sql.NullString); !ok {
return fmt.Errorf("unexpected type %T for field kindBed", values[i])
} else if value.Valid {
br.KindBed = value.String
}
case bedrecord.FieldKindAge:
if value, ok := values[i].(*sql.NullString); !ok {
return fmt.Errorf("unexpected type %T for field kindAge", values[i])
} else if value.Valid {
br.KindAge = value.String
}
}
}
return nil
}
// QueryPlaces queries the "places" edge of the BedRecord entity.
func (br *BedRecord) QueryPlaces() *PlaceQuery {
return (&BedRecordClient{config: br.config}).QueryPlaces(br)
}
// Update returns a builder for updating this BedRecord.
// Note that you need to call BedRecord.Unwrap() before calling this method if this BedRecord
// was returned from a transaction, and the transaction was committed or rolled back.
func (br *BedRecord) Update() *BedRecordUpdateOne {
return (&BedRecordClient{config: br.config}).UpdateOne(br)
}
// Unwrap unwraps the BedRecord entity that was returned from a transaction after it was closed,
// so that all future queries will be executed through the driver which created the transaction.
func (br *BedRecord) Unwrap() *BedRecord {
tx, ok := br.config.driver.(*txDriver)
if !ok {
panic("ent: BedRecord is not a transactional entity")
}
br.config.driver = tx.drv
return br
}
// String implements the fmt.Stringer.
func (br *BedRecord) String() string {
var builder strings.Builder
builder.WriteString("BedRecord(")
builder.WriteString(fmt.Sprintf("id=%v", br.ID))
builder.WriteString(", reportedDate=")
builder.WriteString(br.ReportedDate.Format(time.ANSIC))
builder.WriteString(", collectedDate=")
builder.WriteString(br.CollectedDate.Format(time.ANSIC))
builder.WriteString(", busyBeds=")
builder.WriteString(fmt.Sprintf("%v", br.BusyBeds))
builder.WriteString(", availableBeds=")
builder.WriteString(fmt.Sprintf("%v", br.AvailableBeds))
builder.WriteString(", totalBeds=")
builder.WriteString(fmt.Sprintf("%v", br.TotalBeds))
builder.WriteString(", kindBed=")
builder.WriteString(br.KindBed)
builder.WriteString(", kindAge=")
builder.WriteString(br.KindAge)
builder.WriteByte(')')
return builder.String()
}
// BedRecords is a parsable slice of BedRecord.
type BedRecords []*BedRecord
func (br BedRecords) config(cfg config) {
for _i := range br {
br[_i].config = cfg
}
} | ent/bedrecord.go | 0.657648 | 0.413536 | bedrecord.go | starcoder |
package cios
import (
"encoding/json"
)
// DataStoreChannelStats struct for DataStoreChannelStats
type DataStoreChannelStats struct {
Count *string `json:"count,omitempty"`
Size *string `json:"size,omitempty"`
LatestAt *string `json:"latest_at,omitempty"`
}
// NewDataStoreChannelStats instantiates a new DataStoreChannelStats object
// This constructor will assign default values to properties that have it defined,
// and makes sure properties required by API are set, but the set of arguments
// will change when the set of required properties is changed
func NewDataStoreChannelStats() *DataStoreChannelStats {
this := DataStoreChannelStats{}
return &this
}
// NewDataStoreChannelStatsWithDefaults instantiates a new DataStoreChannelStats object
// This constructor will only assign default values to properties that have it defined,
// but it doesn't guarantee that properties required by API are set
func NewDataStoreChannelStatsWithDefaults() *DataStoreChannelStats {
this := DataStoreChannelStats{}
return &this
}
// GetCount returns the Count field value if set, zero value otherwise.
func (o *DataStoreChannelStats) GetCount() string {
if o == nil || o.Count == nil {
var ret string
return ret
}
return *o.Count
}
// GetCountOk returns a tuple with the Count field value if set, nil otherwise
// and a boolean to check if the value has been set.
func (o *DataStoreChannelStats) GetCountOk() (*string, bool) {
if o == nil || o.Count == nil {
return nil, false
}
return o.Count, true
}
// HasCount returns a boolean if a field has been set.
func (o *DataStoreChannelStats) HasCount() bool {
if o != nil && o.Count != nil {
return true
}
return false
}
// SetCount gets a reference to the given string and assigns it to the Count field.
func (o *DataStoreChannelStats) SetCount(v string) {
o.Count = &v
}
// GetSize returns the Size field value if set, zero value otherwise.
func (o *DataStoreChannelStats) GetSize() string {
if o == nil || o.Size == nil {
var ret string
return ret
}
return *o.Size
}
// GetSizeOk returns a tuple with the Size field value if set, nil otherwise
// and a boolean to check if the value has been set.
func (o *DataStoreChannelStats) GetSizeOk() (*string, bool) {
if o == nil || o.Size == nil {
return nil, false
}
return o.Size, true
}
// HasSize returns a boolean if a field has been set.
func (o *DataStoreChannelStats) HasSize() bool {
if o != nil && o.Size != nil {
return true
}
return false
}
// SetSize gets a reference to the given string and assigns it to the Size field.
func (o *DataStoreChannelStats) SetSize(v string) {
o.Size = &v
}
// GetLatestAt returns the LatestAt field value if set, zero value otherwise.
func (o *DataStoreChannelStats) GetLatestAt() string {
if o == nil || o.LatestAt == nil {
var ret string
return ret
}
return *o.LatestAt
}
// GetLatestAtOk returns a tuple with the LatestAt field value if set, nil otherwise
// and a boolean to check if the value has been set.
func (o *DataStoreChannelStats) GetLatestAtOk() (*string, bool) {
if o == nil || o.LatestAt == nil {
return nil, false
}
return o.LatestAt, true
}
// HasLatestAt returns a boolean if a field has been set.
func (o *DataStoreChannelStats) HasLatestAt() bool {
if o != nil && o.LatestAt != nil {
return true
}
return false
}
// SetLatestAt gets a reference to the given string and assigns it to the LatestAt field.
func (o *DataStoreChannelStats) SetLatestAt(v string) {
o.LatestAt = &v
}
func (o DataStoreChannelStats) MarshalJSON() ([]byte, error) {
toSerialize := map[string]interface{}{}
if o.Count != nil {
toSerialize["count"] = o.Count
}
if o.Size != nil {
toSerialize["size"] = o.Size
}
if o.LatestAt != nil {
toSerialize["latest_at"] = o.LatestAt
}
return json.Marshal(toSerialize)
}
type NullableDataStoreChannelStats struct {
value *DataStoreChannelStats
isSet bool
}
func (v NullableDataStoreChannelStats) Get() *DataStoreChannelStats {
return v.value
}
func (v *NullableDataStoreChannelStats) Set(val *DataStoreChannelStats) {
v.value = val
v.isSet = true
}
func (v NullableDataStoreChannelStats) IsSet() bool {
return v.isSet
}
func (v *NullableDataStoreChannelStats) Unset() {
v.value = nil
v.isSet = false
}
func NewNullableDataStoreChannelStats(val *DataStoreChannelStats) *NullableDataStoreChannelStats {
return &NullableDataStoreChannelStats{value: val, isSet: true}
}
func (v NullableDataStoreChannelStats) MarshalJSON() ([]byte, error) {
return json.Marshal(v.value)
}
func (v *NullableDataStoreChannelStats) UnmarshalJSON(src []byte) error {
v.isSet = true
return json.Unmarshal(src, &v.value)
} | cios/model_data_store_channel_stats.go | 0.786172 | 0.410402 | model_data_store_channel_stats.go | starcoder |
package gohome
import (
"image"
"image/color"
)
// This interface represents a cube map with six faces
type CubeMap interface {
// Loads a cube map from data with width and height
Load(data []byte, width, height int, shadowMap bool)
// Loads the cube map from an image
LoadFromImage(img image.Image)
// Binds the cube map to unit
Bind(unit uint32)
// Unbinds cube map
Unbind(unit uint32)
// Returns the width of the cube map
GetWidth() int
// Returns the height of the cube map
GetHeight() int
// Returns the color that will be keyed
GetKeyColor() color.Color
// Returns the modulate color
GetModColor() color.Color
// Cleans everything up
Terminate()
// Sets filtering to the give method
SetFiltering(filtering int)
// Sets wrapping to the given method
SetWrapping(wrapping int)
// Sets the color of the border to col if used
SetBorderColor(col color.Color)
// Sets the depth of the border
SetBorderDepth(depth float32)
// Sets the key color
SetKeyColor(col color.Color)
// Sets the modulate color
SetModColor(col color.Color)
// Returns the name of this cube map
GetName() string
// Returns the data its with and its height
GetData() ([]byte, int, int)
}
// An implementation of CubeMap that does nothing
type NilCubeMap struct {
}
func (*NilCubeMap) Load(data []byte, width, height int, shadowMap bool) {
}
func (*NilCubeMap) LoadFromImage(img image.Image) {
}
func (*NilCubeMap) Bind(unit uint32) {
}
func (*NilCubeMap) Unbind(unit uint32) {
}
func (*NilCubeMap) GetWidth() int {
return 0
}
func (*NilCubeMap) GetHeight() int {
return 0
}
func (*NilCubeMap) GetKeyColor() color.Color {
return nil
}
func (*NilCubeMap) GetModColor() color.Color {
return nil
}
func (*NilCubeMap) Terminate() {
}
func (*NilCubeMap) SetFiltering(filtering int) {
}
func (*NilCubeMap) SetWrapping(wrapping int) {
}
func (*NilCubeMap) SetBorderColor(col color.Color) {
}
func (*NilCubeMap) SetBorderDepth(depth float32) {
}
func (*NilCubeMap) SetKeyColor(col color.Color) {
}
func (*NilCubeMap) SetModColor(col color.Color) {
}
func (*NilCubeMap) GetName() string {
return ""
}
func (*NilCubeMap) GetData() ([]byte, int, int) {
var data []byte
return data, 0, 0
} | src/gohome/cubemap.go | 0.80502 | 0.454835 | cubemap.go | starcoder |
package scan
import (
"database/sql"
"fmt"
"reflect"
"github.com/jmoiron/sqlx/reflectx"
)
var (
mapper = reflectx.NewMapper("db")
namedArgType = reflect.TypeOf(sql.NamedArg{})
)
// IsNil returns true if the value is nil
func IsNil(src interface{}) bool {
if src == nil {
return true
}
value := reflect.ValueOf(src)
switch value.Kind() {
case reflect.Ptr:
return value.IsNil()
case reflect.Chan:
return value.IsNil()
case reflect.Func:
return value.IsNil()
case reflect.Map:
return value.IsNil()
case reflect.Interface:
return value.IsNil()
case reflect.Slice:
return value.IsNil()
}
return false
}
// IsEmpty returns true if the value is empty
func IsEmpty(src interface{}) bool {
if src == nil {
return true
}
value := reflect.ValueOf(src)
switch value.Kind() {
case reflect.Ptr:
return value.IsNil()
case reflect.Chan:
return value.IsNil()
case reflect.Func:
return value.IsNil()
case reflect.Map:
return value.IsNil()
case reflect.Interface:
return value.IsNil()
case reflect.Slice:
return value.IsNil()
}
return value.IsZero()
}
// Args returns the arguments
func Args(src []interface{}, columns ...string) ([]interface{}, error) {
if len(columns) == 0 {
return src, nil
}
args := make([]interface{}, 0)
for _, arg := range src {
param := reflect.ValueOf(arg)
param = reflect.Indirect(param)
switch k := param.Type().Kind(); {
case k == reflect.String || k >= reflect.Bool && k <= reflect.Float64:
args = append(args, arg)
default:
values, err := valuesOf(param, columns)
if err != nil {
return nil, err
}
args = append(args, values...)
}
}
return args, nil
}
// Values scans a struct and returns the values associated with the columns
// provided. Only simple value types are supported (i.e. Bool, Ints, Uints,
// Floats, Interface, String, NamedArg)
func Values(src interface{}, columns ...string) ([]interface{}, error) {
value, err := valueOf(src)
if err != nil {
return nil, err
}
return valuesOf(value, columns)
}
func valuesOf(value reflect.Value, columns []string) ([]interface{}, error) {
switch value.Kind() {
case reflect.Struct:
switch value.Type() {
case namedArgType:
return valuesOfNamedArg(value, columns)
default:
return valuesOfStruct(value, columns)
}
case reflect.Map:
return valuesOfMap(value, columns)
default:
return nil, fmt.Errorf("sql/scan: invalid type %s. expected struct or map as an argument", value.Kind())
}
}
func valuesOfStruct(target reflect.Value, columns []string) ([]interface{}, error) {
kind := target.Kind()
if kind != reflect.Struct {
return nil, fmt.Errorf("sql/scan: invalid type %s. expected struct as an argument", kind)
}
values := make([]interface{}, 0)
if len(columns) == 0 {
meta := mapper.TypeMap(target.Type())
iter := &Iterator{
meta: meta,
value: target,
index: -1,
}
for iter.Next() {
column := iter.Column()
columns = append(columns, column.Name)
}
}
for _, name := range columns {
if field := fieldByName(target.Type(), name); field != nil {
// find the value
value := valueByIndex(target, field.Index).Interface()
// append it
values = append(values, value)
}
}
return values, nil
}
func valuesOfNamedArg(target reflect.Value, columns []string) ([]interface{}, error) {
var (
values = []interface{}{}
arg = target.Interface().(sql.NamedArg)
)
if len(columns) == 0 {
columns = append(columns, arg.Name)
}
for _, column := range columns {
if column == arg.Name {
values = append(values, arg.Value)
break
}
}
return values, nil
}
func valuesOfMap(value reflect.Value, columns []string) ([]interface{}, error) {
var (
empty = reflect.Value{}
kind = value.Kind()
)
if kind != reflect.Map {
return nil, fmt.Errorf("sql/scan: invalid type %s. expected map as an argument", kind)
}
if keyKind := value.Type().Key().Kind(); keyKind != reflect.String {
return nil, fmt.Errorf("sql/scan: invalid type %s. expected string as an key", keyKind)
}
if len(columns) == 0 {
for _, key := range value.MapKeys() {
columns = append(columns, key.String())
}
}
values := make([]interface{}, 0)
for _, name := range columns {
param := value.MapIndex(reflect.ValueOf(name))
if param == empty {
continue
}
values = append(values, param.Interface())
}
return values, nil
}
func valueOf(src interface{}) (reflect.Value, error) {
var (
empty = reflect.Value{}
typ = reflect.TypeOf(src)
kind = typ.Kind()
)
if kind != reflect.Ptr {
return empty, fmt.Errorf("sql/scan: invalid type %s. expected pointer as an argument", kind)
}
value := reflect.ValueOf(src)
value = reflect.Indirect(value)
return value, nil
} | dialect/sql/scan/value.go | 0.712132 | 0.572006 | value.go | starcoder |
package e2e
import (
"fmt"
"strings"
"time"
"github.com/onsi/ginkgo"
"github.com/onsi/gomega"
v1 "k8s.io/api/core/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
clientset "k8s.io/client-go/kubernetes"
"k8s.io/kubernetes/test/e2e/framework"
)
/*
Test to verify fstype specified in storage-class is being honored after volume creation.
Steps
1. Create StorageClass with fstype set to valid type (default case included).
2. Create PVC which uses the StorageClass created in step 1.
3. Wait for PV to be provisioned.
4. Wait for PVC's status to become Bound.
5. Create pod using PVC on specific node.
6. Wait for Disk to be attached to the node.
7. Execute command in the pod to get fstype.
8. Delete pod and Wait for Volume Disk to be detached from the Node.
9. Delete PVC, PV and Storage Class.
Test to verify if an invalid fstype specified in storage class fails pod creation.
Steps
1. Create StorageClass with inavlid.
2. Create PVC which uses the StorageClass created in step 1.
3. Wait for PV to be provisioned.
4. Wait for PVC's status to become Bound.
5. Create pod using PVC.
6. Verify if the pod creation fails.
7. Verify if the MountVolume.MountDevice fails because it is unable to find the file system executable file on the node.
*/
var _ = ginkgo.Describe("[csi-block-e2e] Volume Filesystem Type Test", func() {
f := framework.NewDefaultFramework("volume-fstype")
var (
client clientset.Interface
namespace string
)
ginkgo.BeforeEach(func() {
client = f.ClientSet
namespace = f.Namespace.Name
bootstrap()
nodeList := framework.GetReadySchedulableNodesOrDie(f.ClientSet)
if !(len(nodeList.Items) > 0) {
framework.Failf("Unable to find ready and schedulable Node")
}
})
ginkgo.It("CSI - verify fstype - ext3 formatted volume", func() {
invokeTestForFstype(f, client, namespace, ext3FSType, ext3FSType)
})
ginkgo.It("CSI - verify fstype - default value should be ext4", func() {
invokeTestForFstype(f, client, namespace, "", ext4FSType)
})
ginkgo.It("CSI - verify invalid fstype", func() {
invokeTestForInvalidFstype(f, client, namespace, invalidFSType)
})
})
func invokeTestForFstype(f *framework.Framework, client clientset.Interface, namespace string, fstype string, expectedContent string) {
ginkgo.By(fmt.Sprintf("Invoking Test for fstype: %s", fstype))
scParameters := make(map[string]string)
scParameters["fstype"] = fstype
// Create Storage class and PVC
ginkgo.By("Creating Storage Class With Fstype")
storageclass, pvclaim, err := createPVCAndStorageClass(client, namespace, nil, scParameters, "", nil, "")
gomega.Expect(err).NotTo(gomega.HaveOccurred())
defer client.StorageV1().StorageClasses().Delete(storageclass.Name, nil)
// Waiting for PVC to be bound
var pvclaims []*v1.PersistentVolumeClaim
pvclaims = append(pvclaims, pvclaim)
ginkgo.By("Waiting for all claims to be in bound state")
persistentvolumes, err := framework.WaitForPVClaimBoundPhase(client, pvclaims, framework.ClaimProvisionTimeout)
gomega.Expect(err).NotTo(gomega.HaveOccurred())
// Create a POD to use this PVC, and verify volume has been attached
ginkgo.By("Creating pod to attach PV to the node")
pod, err := framework.CreatePod(client, namespace, nil, []*v1.PersistentVolumeClaim{pvclaim}, false, execCommand)
gomega.Expect(err).NotTo(gomega.HaveOccurred())
ginkgo.By("Verify volume is attached to the node")
pv := persistentvolumes[0]
isDiskAttached, err := e2eVSphere.isVolumeAttachedToNode(client, pv.Spec.CSI.VolumeHandle, pod.Spec.NodeName)
gomega.Expect(err).NotTo(gomega.HaveOccurred())
gomega.Expect(isDiskAttached).To(gomega.BeTrue(), fmt.Sprintf("Volume is not attached to the node"))
ginkgo.By("Verify the volume is accessible and filesystem type is as expected")
_, err = framework.LookForStringInPodExec(namespace, pod.Name, []string{"/bin/cat", "/mnt/volume1/fstype"}, expectedContent, time.Minute)
gomega.Expect(err).NotTo(gomega.HaveOccurred())
// Delete POD and PVC
ginkgo.By("Deleting the pod")
framework.DeletePodWithWait(f, client, pod)
ginkgo.By("Verify volume is detached from the node")
isDiskDetached, err := e2eVSphere.waitForVolumeDetachedFromNode(client, pv.Spec.CSI.VolumeHandle, pod.Spec.NodeName)
gomega.Expect(err).NotTo(gomega.HaveOccurred())
gomega.Expect(isDiskDetached).To(gomega.BeTrue(), fmt.Sprintf("Volume %q is not detached from the node %q", pv.Spec.CSI.VolumeHandle, pod.Spec.NodeName))
err = framework.DeletePersistentVolumeClaim(client, pvclaim.Name, namespace)
gomega.Expect(err).NotTo(gomega.HaveOccurred())
}
func invokeTestForInvalidFstype(f *framework.Framework, client clientset.Interface, namespace string, fstype string) {
scParameters := make(map[string]string)
scParameters["fstype"] = fstype
// Create Storage class and PVC
ginkgo.By("Creating Storage Class With Invalid Fstype")
storageclass, pvclaim, err := createPVCAndStorageClass(client, namespace, nil, scParameters, "", nil, "")
gomega.Expect(err).NotTo(gomega.HaveOccurred())
defer client.StorageV1().StorageClasses().Delete(storageclass.Name, nil)
// Waiting for PVC to be bound
var pvclaims []*v1.PersistentVolumeClaim
pvclaims = append(pvclaims, pvclaim)
ginkgo.By("Waiting for all claims to be in bound state")
persistentvolumes, err := framework.WaitForPVClaimBoundPhase(client, pvclaims, framework.ClaimProvisionTimeout)
gomega.Expect(err).NotTo(gomega.HaveOccurred())
// Create a POD to use this PVC, and verify volume has been attached
ginkgo.By("Creating pod to attach PV to the node")
pod, err := framework.CreatePod(client, namespace, nil, []*v1.PersistentVolumeClaim{pvclaim}, false, execCommand)
gomega.Expect(err).To(gomega.HaveOccurred())
eventList, err := client.CoreV1().Events(namespace).List(metav1.ListOptions{})
gomega.Expect(err).NotTo(gomega.HaveOccurred())
gomega.Expect(eventList.Items).NotTo(gomega.BeEmpty())
pv := persistentvolumes[0]
errorMsg := `MountVolume.MountDevice failed for volume "` + pv.Name
isFailureFound := false
for _, item := range eventList.Items {
ginkgo.By(fmt.Sprintf("Print errorMessage %q \n", item.Message))
if strings.Contains(item.Message, errorMsg) {
isFailureFound = true
}
}
gomega.Expect(isFailureFound).To(gomega.BeTrue(), "Unable to verify MountVolume.MountDevice failure")
// pod.Spec.NodeName may not be set yet when pod just created
// refetch pod to get pod.Spec.NodeName
podNodeName := pod.Spec.NodeName
ginkgo.By(fmt.Sprintf("podNodeName: %v podName: %v", podNodeName, pod.Name))
pod, err = client.CoreV1().Pods(pod.Namespace).Get(pod.Name, metav1.GetOptions{})
gomega.Expect(err).NotTo(gomega.HaveOccurred())
podNodeName = pod.Spec.NodeName
ginkgo.By(fmt.Sprintf("Refetch the POD: podNodeName: %v podName: %v", podNodeName, pod.Name))
// Delete POD and PVC
ginkgo.By("Deleting the pod")
framework.DeletePodWithWait(f, client, pod)
ginkgo.By("Verify volume is detached from the node")
isDiskDetached, err := e2eVSphere.waitForVolumeDetachedFromNode(client, pv.Spec.CSI.VolumeHandle, podNodeName)
gomega.Expect(err).NotTo(gomega.HaveOccurred())
gomega.Expect(isDiskDetached).To(gomega.BeTrue(), fmt.Sprintf("Volume %q is not detached from the node %q", pv.Spec.CSI.VolumeHandle, podNodeName))
err = framework.DeletePersistentVolumeClaim(client, pvclaim.Name, namespace)
gomega.Expect(err).NotTo(gomega.HaveOccurred())
} | tests/e2e/vsphere_volume_fstype.go | 0.562177 | 0.405449 | vsphere_volume_fstype.go | starcoder |
package sqlb
import r "reflect"
/*
Short for "expression". Defines an arbitrary SQL expression. The method appends
arbitrary SQL text. In both the input and output, the arguments must correspond
to the parameters in the SQL text. Different databases support different styles
of ordinal parameters. This package always generates Postgres-style ordinal
parameters such as "$1", renumerating them as necessary.
This method is allowed to panic. Use `(*Bui).CatchExprs` to catch
expression-encoding panics and convert them to errors.
All `Expr` types in this package also implement `Appender` and `fmt.Stringer`.
*/
type Expr interface {
AppendExpr([]byte, []interface{}) ([]byte, []interface{})
}
/*
Short for "parametrized expression". Similar to `Expr`, but requires an external
input in order to be a valid expression. Implemented by preparsed query types,
namely by `Prep`.
*/
type ParamExpr interface {
AppendParamExpr([]byte, []interface{}, ArgDict) ([]byte, []interface{})
}
/*
Appends a text repesentation. Sometimes allows better efficiency than
`fmt.Stringer`. Implemented by all `Expr` types in this package.
*/
type Appender interface{ Append([]byte) []byte }
/*
Dictionary of arbitrary arguments, ordinal and/or named. Used as input to
`ParamExpr`(parametrized expressions). This package provides multiple
implementations: slice-based `List`, map-based `Dict`, and struct-based
`StructDict`. May optionally implement `OrdinalRanger` and `NamedRanger` to
validate used/unused arguments.
*/
type ArgDict interface {
IsEmpty() bool
Len() int
GotOrdinal(int) (interface{}, bool)
GotNamed(string) (interface{}, bool)
}
/*
Optional extension for `ArgDict`. If implemented, this is used to validate
used/unused ordinal arguments after building a parametrized SQL expression such
as `StrQ`/`Prep`.
*/
type OrdinalRanger interface {
/**
Must iterate over argument indexes from 0 to N, calling the function for each
index. The func is provided by this package, and will panic for each unused
argument.
*/
RangeOrdinal(func(int))
}
/*
Optional extension for `ArgDict`. If implemented, this is used to validate
used/unused named arguments after building a parametrized SQL expression such
as `StrQ`/`Prep`.
*/
type NamedRanger interface {
/**
Must iterate over known argument names, calling the function for each name.
The func is provided by this package, and will panic for each unused
argument.
*/
RangeNamed(func(string))
}
/*
Used by `Partial` for filtering struct fields. See `Sparse` and `Partial` for
explanations.
*/
type Haser interface{ Has(string) bool }
/*
Represents an arbitrary struct where not all fields are "present". Calling
`.Get` returns the underlying struct value. Calling `.AllowField` answers the
question "is this field present?".
Secretly supported by struct-scanning expressions such as `StructInsert`,
`StructAssign`, `StructValues`, `Cond`, and more. These types attempt to upcast
the inner value to `Sparse`, falling back on using the inner value as-is. This
allows to correctly implement REST PATCH semantics by using only the fields
that were present in a particular HTTP request, while keeping this
functionality optional.
Concrete implementation: `Partial`.
*/
type Sparse interface {
Filter
Get() interface{}
}
/*
Filters struct fields. Used by `Sparse` and `ParseOpt`. Implemented by
`TagFilter`.
*/
type Filter interface{ AllowField(r.StructField) bool }
/*
Optional interface that allows `sqlb` to determine if a given value is null,
allowing some expressions to generate `is null` / `is not null` clauses. Not
actually required; nils of Go nilable types are automatically considered null,
and `sqlb` falls back on encoding the value via `driver.Valuer`. This interface
is supported for additional flexibility and efficiency.
*/
type Nullable interface{ IsNull() bool } | sqlb.go | 0.823044 | 0.554591 | sqlb.go | starcoder |
package models
import (
i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91 "github.com/microsoft/kiota-abstractions-go/serialization"
)
// WorkbookTable
type WorkbookTable struct {
Entity
// Represents a collection of all the columns in the table. Read-only.
columns []WorkbookTableColumnable
// Indicates whether the first column contains special formatting.
highlightFirstColumn *bool
// Indicates whether the last column contains special formatting.
highlightLastColumn *bool
// Legacy Id used in older Excle clients. The value of the identifier remains the same even when the table is renamed. This property should be interpreted as an opaque string value and should not be parsed to any other type. Read-only.
legacyId *string
// Name of the table.
name *string
// Represents a collection of all the rows in the table. Read-only.
rows []WorkbookTableRowable
// Indicates whether the columns show banded formatting in which odd columns are highlighted differently from even ones to make reading the table easier.
showBandedColumns *bool
// Indicates whether the rows show banded formatting in which odd rows are highlighted differently from even ones to make reading the table easier.
showBandedRows *bool
// Indicates whether the filter buttons are visible at the top of each column header. Setting this is only allowed if the table contains a header row.
showFilterButton *bool
// Indicates whether the header row is visible or not. This value can be set to show or remove the header row.
showHeaders *bool
// Indicates whether the total row is visible or not. This value can be set to show or remove the total row.
showTotals *bool
// Represents the sorting for the table. Read-only.
sort WorkbookTableSortable
// Constant value that represents the Table style. Possible values are: TableStyleLight1 thru TableStyleLight21, TableStyleMedium1 thru TableStyleMedium28, TableStyleStyleDark1 thru TableStyleStyleDark11. A custom user-defined style present in the workbook can also be specified.
style *string
// The worksheet containing the current table. Read-only.
worksheet WorkbookWorksheetable
}
// NewWorkbookTable instantiates a new workbookTable and sets the default values.
func NewWorkbookTable()(*WorkbookTable) {
m := &WorkbookTable{
Entity: *NewEntity(),
}
return m
}
// CreateWorkbookTableFromDiscriminatorValue creates a new instance of the appropriate class based on discriminator value
func CreateWorkbookTableFromDiscriminatorValue(parseNode i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.ParseNode)(i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.Parsable, error) {
return NewWorkbookTable(), nil
}
// GetColumns gets the columns property value. Represents a collection of all the columns in the table. Read-only.
func (m *WorkbookTable) GetColumns()([]WorkbookTableColumnable) {
if m == nil {
return nil
} else {
return m.columns
}
}
// GetFieldDeserializers the deserialization information for the current model
func (m *WorkbookTable) GetFieldDeserializers()(map[string]func(i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.ParseNode)(error)) {
res := m.Entity.GetFieldDeserializers()
res["columns"] = func (n i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.ParseNode) error {
val, err := n.GetCollectionOfObjectValues(CreateWorkbookTableColumnFromDiscriminatorValue)
if err != nil {
return err
}
if val != nil {
res := make([]WorkbookTableColumnable, len(val))
for i, v := range val {
res[i] = v.(WorkbookTableColumnable)
}
m.SetColumns(res)
}
return nil
}
res["highlightFirstColumn"] = func (n i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.ParseNode) error {
val, err := n.GetBoolValue()
if err != nil {
return err
}
if val != nil {
m.SetHighlightFirstColumn(val)
}
return nil
}
res["highlightLastColumn"] = func (n i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.ParseNode) error {
val, err := n.GetBoolValue()
if err != nil {
return err
}
if val != nil {
m.SetHighlightLastColumn(val)
}
return nil
}
res["legacyId"] = func (n i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.ParseNode) error {
val, err := n.GetStringValue()
if err != nil {
return err
}
if val != nil {
m.SetLegacyId(val)
}
return nil
}
res["name"] = func (n i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.ParseNode) error {
val, err := n.GetStringValue()
if err != nil {
return err
}
if val != nil {
m.SetName(val)
}
return nil
}
res["rows"] = func (n i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.ParseNode) error {
val, err := n.GetCollectionOfObjectValues(CreateWorkbookTableRowFromDiscriminatorValue)
if err != nil {
return err
}
if val != nil {
res := make([]WorkbookTableRowable, len(val))
for i, v := range val {
res[i] = v.(WorkbookTableRowable)
}
m.SetRows(res)
}
return nil
}
res["showBandedColumns"] = func (n i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.ParseNode) error {
val, err := n.GetBoolValue()
if err != nil {
return err
}
if val != nil {
m.SetShowBandedColumns(val)
}
return nil
}
res["showBandedRows"] = func (n i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.ParseNode) error {
val, err := n.GetBoolValue()
if err != nil {
return err
}
if val != nil {
m.SetShowBandedRows(val)
}
return nil
}
res["showFilterButton"] = func (n i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.ParseNode) error {
val, err := n.GetBoolValue()
if err != nil {
return err
}
if val != nil {
m.SetShowFilterButton(val)
}
return nil
}
res["showHeaders"] = func (n i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.ParseNode) error {
val, err := n.GetBoolValue()
if err != nil {
return err
}
if val != nil {
m.SetShowHeaders(val)
}
return nil
}
res["showTotals"] = func (n i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.ParseNode) error {
val, err := n.GetBoolValue()
if err != nil {
return err
}
if val != nil {
m.SetShowTotals(val)
}
return nil
}
res["sort"] = func (n i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.ParseNode) error {
val, err := n.GetObjectValue(CreateWorkbookTableSortFromDiscriminatorValue)
if err != nil {
return err
}
if val != nil {
m.SetSort(val.(WorkbookTableSortable))
}
return nil
}
res["style"] = func (n i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.ParseNode) error {
val, err := n.GetStringValue()
if err != nil {
return err
}
if val != nil {
m.SetStyle(val)
}
return nil
}
res["worksheet"] = func (n i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.ParseNode) error {
val, err := n.GetObjectValue(CreateWorkbookWorksheetFromDiscriminatorValue)
if err != nil {
return err
}
if val != nil {
m.SetWorksheet(val.(WorkbookWorksheetable))
}
return nil
}
return res
}
// GetHighlightFirstColumn gets the highlightFirstColumn property value. Indicates whether the first column contains special formatting.
func (m *WorkbookTable) GetHighlightFirstColumn()(*bool) {
if m == nil {
return nil
} else {
return m.highlightFirstColumn
}
}
// GetHighlightLastColumn gets the highlightLastColumn property value. Indicates whether the last column contains special formatting.
func (m *WorkbookTable) GetHighlightLastColumn()(*bool) {
if m == nil {
return nil
} else {
return m.highlightLastColumn
}
}
// GetLegacyId gets the legacyId property value. Legacy Id used in older Excle clients. The value of the identifier remains the same even when the table is renamed. This property should be interpreted as an opaque string value and should not be parsed to any other type. Read-only.
func (m *WorkbookTable) GetLegacyId()(*string) {
if m == nil {
return nil
} else {
return m.legacyId
}
}
// GetName gets the name property value. Name of the table.
func (m *WorkbookTable) GetName()(*string) {
if m == nil {
return nil
} else {
return m.name
}
}
// GetRows gets the rows property value. Represents a collection of all the rows in the table. Read-only.
func (m *WorkbookTable) GetRows()([]WorkbookTableRowable) {
if m == nil {
return nil
} else {
return m.rows
}
}
// GetShowBandedColumns gets the showBandedColumns property value. Indicates whether the columns show banded formatting in which odd columns are highlighted differently from even ones to make reading the table easier.
func (m *WorkbookTable) GetShowBandedColumns()(*bool) {
if m == nil {
return nil
} else {
return m.showBandedColumns
}
}
// GetShowBandedRows gets the showBandedRows property value. Indicates whether the rows show banded formatting in which odd rows are highlighted differently from even ones to make reading the table easier.
func (m *WorkbookTable) GetShowBandedRows()(*bool) {
if m == nil {
return nil
} else {
return m.showBandedRows
}
}
// GetShowFilterButton gets the showFilterButton property value. Indicates whether the filter buttons are visible at the top of each column header. Setting this is only allowed if the table contains a header row.
func (m *WorkbookTable) GetShowFilterButton()(*bool) {
if m == nil {
return nil
} else {
return m.showFilterButton
}
}
// GetShowHeaders gets the showHeaders property value. Indicates whether the header row is visible or not. This value can be set to show or remove the header row.
func (m *WorkbookTable) GetShowHeaders()(*bool) {
if m == nil {
return nil
} else {
return m.showHeaders
}
}
// GetShowTotals gets the showTotals property value. Indicates whether the total row is visible or not. This value can be set to show or remove the total row.
func (m *WorkbookTable) GetShowTotals()(*bool) {
if m == nil {
return nil
} else {
return m.showTotals
}
}
// GetSort gets the sort property value. Represents the sorting for the table. Read-only.
func (m *WorkbookTable) GetSort()(WorkbookTableSortable) {
if m == nil {
return nil
} else {
return m.sort
}
}
// GetStyle gets the style property value. Constant value that represents the Table style. Possible values are: TableStyleLight1 thru TableStyleLight21, TableStyleMedium1 thru TableStyleMedium28, TableStyleStyleDark1 thru TableStyleStyleDark11. A custom user-defined style present in the workbook can also be specified.
func (m *WorkbookTable) GetStyle()(*string) {
if m == nil {
return nil
} else {
return m.style
}
}
// GetWorksheet gets the worksheet property value. The worksheet containing the current table. Read-only.
func (m *WorkbookTable) GetWorksheet()(WorkbookWorksheetable) {
if m == nil {
return nil
} else {
return m.worksheet
}
}
// Serialize serializes information the current object
func (m *WorkbookTable) Serialize(writer i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.SerializationWriter)(error) {
err := m.Entity.Serialize(writer)
if err != nil {
return err
}
if m.GetColumns() != nil {
cast := make([]i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.Parsable, len(m.GetColumns()))
for i, v := range m.GetColumns() {
cast[i] = v.(i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.Parsable)
}
err = writer.WriteCollectionOfObjectValues("columns", cast)
if err != nil {
return err
}
}
{
err = writer.WriteBoolValue("highlightFirstColumn", m.GetHighlightFirstColumn())
if err != nil {
return err
}
}
{
err = writer.WriteBoolValue("highlightLastColumn", m.GetHighlightLastColumn())
if err != nil {
return err
}
}
{
err = writer.WriteStringValue("legacyId", m.GetLegacyId())
if err != nil {
return err
}
}
{
err = writer.WriteStringValue("name", m.GetName())
if err != nil {
return err
}
}
if m.GetRows() != nil {
cast := make([]i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.Parsable, len(m.GetRows()))
for i, v := range m.GetRows() {
cast[i] = v.(i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.Parsable)
}
err = writer.WriteCollectionOfObjectValues("rows", cast)
if err != nil {
return err
}
}
{
err = writer.WriteBoolValue("showBandedColumns", m.GetShowBandedColumns())
if err != nil {
return err
}
}
{
err = writer.WriteBoolValue("showBandedRows", m.GetShowBandedRows())
if err != nil {
return err
}
}
{
err = writer.WriteBoolValue("showFilterButton", m.GetShowFilterButton())
if err != nil {
return err
}
}
{
err = writer.WriteBoolValue("showHeaders", m.GetShowHeaders())
if err != nil {
return err
}
}
{
err = writer.WriteBoolValue("showTotals", m.GetShowTotals())
if err != nil {
return err
}
}
{
err = writer.WriteObjectValue("sort", m.GetSort())
if err != nil {
return err
}
}
{
err = writer.WriteStringValue("style", m.GetStyle())
if err != nil {
return err
}
}
{
err = writer.WriteObjectValue("worksheet", m.GetWorksheet())
if err != nil {
return err
}
}
return nil
}
// SetColumns sets the columns property value. Represents a collection of all the columns in the table. Read-only.
func (m *WorkbookTable) SetColumns(value []WorkbookTableColumnable)() {
if m != nil {
m.columns = value
}
}
// SetHighlightFirstColumn sets the highlightFirstColumn property value. Indicates whether the first column contains special formatting.
func (m *WorkbookTable) SetHighlightFirstColumn(value *bool)() {
if m != nil {
m.highlightFirstColumn = value
}
}
// SetHighlightLastColumn sets the highlightLastColumn property value. Indicates whether the last column contains special formatting.
func (m *WorkbookTable) SetHighlightLastColumn(value *bool)() {
if m != nil {
m.highlightLastColumn = value
}
}
// SetLegacyId sets the legacyId property value. Legacy Id used in older Excle clients. The value of the identifier remains the same even when the table is renamed. This property should be interpreted as an opaque string value and should not be parsed to any other type. Read-only.
func (m *WorkbookTable) SetLegacyId(value *string)() {
if m != nil {
m.legacyId = value
}
}
// SetName sets the name property value. Name of the table.
func (m *WorkbookTable) SetName(value *string)() {
if m != nil {
m.name = value
}
}
// SetRows sets the rows property value. Represents a collection of all the rows in the table. Read-only.
func (m *WorkbookTable) SetRows(value []WorkbookTableRowable)() {
if m != nil {
m.rows = value
}
}
// SetShowBandedColumns sets the showBandedColumns property value. Indicates whether the columns show banded formatting in which odd columns are highlighted differently from even ones to make reading the table easier.
func (m *WorkbookTable) SetShowBandedColumns(value *bool)() {
if m != nil {
m.showBandedColumns = value
}
}
// SetShowBandedRows sets the showBandedRows property value. Indicates whether the rows show banded formatting in which odd rows are highlighted differently from even ones to make reading the table easier.
func (m *WorkbookTable) SetShowBandedRows(value *bool)() {
if m != nil {
m.showBandedRows = value
}
}
// SetShowFilterButton sets the showFilterButton property value. Indicates whether the filter buttons are visible at the top of each column header. Setting this is only allowed if the table contains a header row.
func (m *WorkbookTable) SetShowFilterButton(value *bool)() {
if m != nil {
m.showFilterButton = value
}
}
// SetShowHeaders sets the showHeaders property value. Indicates whether the header row is visible or not. This value can be set to show or remove the header row.
func (m *WorkbookTable) SetShowHeaders(value *bool)() {
if m != nil {
m.showHeaders = value
}
}
// SetShowTotals sets the showTotals property value. Indicates whether the total row is visible or not. This value can be set to show or remove the total row.
func (m *WorkbookTable) SetShowTotals(value *bool)() {
if m != nil {
m.showTotals = value
}
}
// SetSort sets the sort property value. Represents the sorting for the table. Read-only.
func (m *WorkbookTable) SetSort(value WorkbookTableSortable)() {
if m != nil {
m.sort = value
}
}
// SetStyle sets the style property value. Constant value that represents the Table style. Possible values are: TableStyleLight1 thru TableStyleLight21, TableStyleMedium1 thru TableStyleMedium28, TableStyleStyleDark1 thru TableStyleStyleDark11. A custom user-defined style present in the workbook can also be specified.
func (m *WorkbookTable) SetStyle(value *string)() {
if m != nil {
m.style = value
}
}
// SetWorksheet sets the worksheet property value. The worksheet containing the current table. Read-only.
func (m *WorkbookTable) SetWorksheet(value WorkbookWorksheetable)() {
if m != nil {
m.worksheet = value
}
} | models/workbook_table.go | 0.664214 | 0.409575 | workbook_table.go | starcoder |
package box2d
import (
"fmt"
"math"
)
/// Wheel joint definition. This requires defining a line of
/// motion using an axis and an anchor point. The definition uses local
/// anchor points and a local axis so that the initial configuration
/// can violate the constraint slightly. The joint translation is zero
/// when the local anchor points coincide in world space. Using local
/// anchors and a local axis helps when saving and loading a game.
type B2WheelJointDef struct {
B2JointDef
/// The local anchor point relative to bodyA's origin.
LocalAnchorA B2Vec2
/// The local anchor point relative to bodyB's origin.
LocalAnchorB B2Vec2
/// The local translation axis in bodyA.
LocalAxisA B2Vec2
/// Enable/disable the joint motor.
EnableMotor bool
/// The maximum motor torque, usually in N-m.
MaxMotorTorque float64
/// The desired motor speed in radians per second.
MotorSpeed float64
/// Suspension frequency, zero indicates no suspension
FrequencyHz float64
/// Suspension damping ratio, one indicates critical damping
DampingRatio float64
}
func MakeB2WheelJointDef() B2WheelJointDef {
res := B2WheelJointDef{
B2JointDef: MakeB2JointDef(),
}
res.Type = B2JointType.E_wheelJoint
res.LocalAnchorA.SetZero()
res.LocalAnchorB.SetZero()
res.LocalAxisA.Set(1.0, 0.0)
res.EnableMotor = false
res.MaxMotorTorque = 0.0
res.MotorSpeed = 0.0
res.FrequencyHz = 2.0
res.DampingRatio = 0.7
return res
}
/// A wheel joint. This joint provides two degrees of freedom: translation
/// along an axis fixed in bodyA and rotation in the plane. In other words, it is a point to
/// line constraint with a rotational motor and a linear spring/damper.
/// This joint is designed for vehicle suspensions.
type B2WheelJoint struct {
*B2Joint
M_frequencyHz float64
M_dampingRatio float64
// Solver shared
M_localAnchorA B2Vec2
M_localAnchorB B2Vec2
M_localXAxisA B2Vec2
M_localYAxisA B2Vec2
M_impulse float64
M_motorImpulse float64
M_springImpulse float64
M_maxMotorTorque float64
M_motorSpeed float64
M_enableMotor bool
// Solver temp
M_indexA int
M_indexB int
M_localCenterA B2Vec2
M_localCenterB B2Vec2
M_invMassA float64
M_invMassB float64
M_invIA float64
M_invIB float64
M_ax B2Vec2
M_ay B2Vec2
M_sAx float64
M_sBx float64
M_sAy float64
M_sBy float64
M_mass float64
M_motorMass float64
M_springMass float64
M_bias float64
M_gamma float64
}
/// The local anchor point relative to bodyA's origin.
func (joint B2WheelJoint) GetLocalAnchorA() B2Vec2 {
return joint.M_localAnchorA
}
/// The local anchor point relative to bodyB's origin.
func (joint B2WheelJoint) GetLocalAnchorB() B2Vec2 {
return joint.M_localAnchorB
}
/// The local joint axis relative to bodyA.
func (joint B2WheelJoint) GetLocalAxisA() B2Vec2 {
return joint.M_localXAxisA
}
func (joint B2WheelJoint) GetMotorSpeed() float64 {
return joint.M_motorSpeed
}
func (joint B2WheelJoint) GetMaxMotorTorque() float64 {
return joint.M_maxMotorTorque
}
func (joint *B2WheelJoint) SetSpringFrequencyHz(hz float64) {
joint.M_frequencyHz = hz
}
func (joint B2WheelJoint) GetSpringFrequencyHz() float64 {
return joint.M_frequencyHz
}
func (joint *B2WheelJoint) SetSpringDampingRatio(ratio float64) {
joint.M_dampingRatio = ratio
}
func (joint B2WheelJoint) GetSpringDampingRatio() float64 {
return joint.M_dampingRatio
}
// Linear constraint (point-to-line)
// d = pB - pA = xB + rB - xA - rA
// C = dot(ay, d)
// Cdot = dot(d, cross(wA, ay)) + dot(ay, vB + cross(wB, rB) - vA - cross(wA, rA))
// = -dot(ay, vA) - dot(cross(d + rA, ay), wA) + dot(ay, vB) + dot(cross(rB, ay), vB)
// J = [-ay, -cross(d + rA, ay), ay, cross(rB, ay)]
// Spring linear constraint
// C = dot(ax, d)
// Cdot = = -dot(ax, vA) - dot(cross(d + rA, ax), wA) + dot(ax, vB) + dot(cross(rB, ax), vB)
// J = [-ax -cross(d+rA, ax) ax cross(rB, ax)]
// Motor rotational constraint
// Cdot = wB - wA
// J = [0 0 -1 0 0 1]
func (def *B2WheelJointDef) Initialize(bA *B2Body, bB *B2Body, anchor B2Vec2, axis B2Vec2) {
def.BodyA = bA
def.BodyB = bB
def.LocalAnchorA = def.BodyA.GetLocalPoint(anchor)
def.LocalAnchorB = def.BodyB.GetLocalPoint(anchor)
def.LocalAxisA = def.BodyA.GetLocalVector(axis)
}
func MakeB2WheelJoint(def *B2WheelJointDef) *B2WheelJoint {
res := B2WheelJoint{
B2Joint: MakeB2Joint(def),
}
res.M_localAnchorA = def.LocalAnchorA
res.M_localAnchorB = def.LocalAnchorB
res.M_localXAxisA = def.LocalAxisA
res.M_localYAxisA = B2Vec2CrossScalarVector(1.0, res.M_localXAxisA)
res.M_mass = 0.0
res.M_impulse = 0.0
res.M_motorMass = 0.0
res.M_motorImpulse = 0.0
res.M_springMass = 0.0
res.M_springImpulse = 0.0
res.M_maxMotorTorque = def.MaxMotorTorque
res.M_motorSpeed = def.MotorSpeed
res.M_enableMotor = def.EnableMotor
res.M_frequencyHz = def.FrequencyHz
res.M_dampingRatio = def.DampingRatio
res.M_bias = 0.0
res.M_gamma = 0.0
res.M_ax.SetZero()
res.M_ay.SetZero()
return &res
}
func (joint *B2WheelJoint) InitVelocityConstraints(data B2SolverData) {
joint.M_indexA = joint.M_bodyA.M_islandIndex
joint.M_indexB = joint.M_bodyB.M_islandIndex
joint.M_localCenterA = joint.M_bodyA.M_sweep.LocalCenter
joint.M_localCenterB = joint.M_bodyB.M_sweep.LocalCenter
joint.M_invMassA = joint.M_bodyA.M_invMass
joint.M_invMassB = joint.M_bodyB.M_invMass
joint.M_invIA = joint.M_bodyA.M_invI
joint.M_invIB = joint.M_bodyB.M_invI
mA := joint.M_invMassA
mB := joint.M_invMassB
iA := joint.M_invIA
iB := joint.M_invIB
cA := data.Positions[joint.M_indexA].C
aA := data.Positions[joint.M_indexA].A
vA := data.Velocities[joint.M_indexA].V
wA := data.Velocities[joint.M_indexA].W
cB := data.Positions[joint.M_indexB].C
aB := data.Positions[joint.M_indexB].A
vB := data.Velocities[joint.M_indexB].V
wB := data.Velocities[joint.M_indexB].W
qA := MakeB2RotFromAngle(aA)
qB := MakeB2RotFromAngle(aB)
// Compute the effective masses.
rA := B2RotVec2Mul(qA, B2Vec2Sub(joint.M_localAnchorA, joint.M_localCenterA))
rB := B2RotVec2Mul(qB, B2Vec2Sub(joint.M_localAnchorB, joint.M_localCenterB))
d := B2Vec2Sub(B2Vec2Sub(B2Vec2Add(cB, rB), cA), rA)
// Point to line constraint
{
joint.M_ay = B2RotVec2Mul(qA, joint.M_localYAxisA)
joint.M_sAy = B2Vec2Cross(B2Vec2Add(d, rA), joint.M_ay)
joint.M_sBy = B2Vec2Cross(rB, joint.M_ay)
joint.M_mass = mA + mB + iA*joint.M_sAy*joint.M_sAy + iB*joint.M_sBy*joint.M_sBy
if joint.M_mass > 0.0 {
joint.M_mass = 1.0 / joint.M_mass
}
}
// Spring constraint
joint.M_springMass = 0.0
joint.M_bias = 0.0
joint.M_gamma = 0.0
if joint.M_frequencyHz > 0.0 {
joint.M_ax = B2RotVec2Mul(qA, joint.M_localXAxisA)
joint.M_sAx = B2Vec2Cross(B2Vec2Add(d, rA), joint.M_ax)
joint.M_sBx = B2Vec2Cross(rB, joint.M_ax)
invMass := mA + mB + iA*joint.M_sAx*joint.M_sAx + iB*joint.M_sBx*joint.M_sBx
if invMass > 0.0 {
joint.M_springMass = 1.0 / invMass
C := B2Vec2Dot(d, joint.M_ax)
// Frequency
omega := 2.0 * B2_pi * joint.M_frequencyHz
// Damping coefficient
damp := 2.0 * joint.M_springMass * joint.M_dampingRatio * omega
// Spring stiffness
k := joint.M_springMass * omega * omega
// magic formulas
h := data.Step.Dt
joint.M_gamma = h * (damp + h*k)
if joint.M_gamma > 0.0 {
joint.M_gamma = 1.0 / joint.M_gamma
}
joint.M_bias = C * h * k * joint.M_gamma
joint.M_springMass = invMass + joint.M_gamma
if joint.M_springMass > 0.0 {
joint.M_springMass = 1.0 / joint.M_springMass
}
}
} else {
joint.M_springImpulse = 0.0
}
// Rotational motor
if joint.M_enableMotor {
joint.M_motorMass = iA + iB
if joint.M_motorMass > 0.0 {
joint.M_motorMass = 1.0 / joint.M_motorMass
}
} else {
joint.M_motorMass = 0.0
joint.M_motorImpulse = 0.0
}
if data.Step.WarmStarting {
// Account for variable time step.
joint.M_impulse *= data.Step.DtRatio
joint.M_springImpulse *= data.Step.DtRatio
joint.M_motorImpulse *= data.Step.DtRatio
P := B2Vec2Add(B2Vec2MulScalar(joint.M_impulse, joint.M_ay), B2Vec2MulScalar(joint.M_springImpulse, joint.M_ax))
LA := joint.M_impulse*joint.M_sAy + joint.M_springImpulse*joint.M_sAx + joint.M_motorImpulse
LB := joint.M_impulse*joint.M_sBy + joint.M_springImpulse*joint.M_sBx + joint.M_motorImpulse
vA.OperatorMinusInplace(B2Vec2MulScalar(joint.M_invMassA, P))
wA -= joint.M_invIA * LA
vB.OperatorPlusInplace(B2Vec2MulScalar(joint.M_invMassB, P))
wB += joint.M_invIB * LB
} else {
joint.M_impulse = 0.0
joint.M_springImpulse = 0.0
joint.M_motorImpulse = 0.0
}
data.Velocities[joint.M_indexA].V = vA
data.Velocities[joint.M_indexA].W = wA
data.Velocities[joint.M_indexB].V = vB
data.Velocities[joint.M_indexB].W = wB
}
func (joint *B2WheelJoint) SolveVelocityConstraints(data B2SolverData) {
mA := joint.M_invMassA
mB := joint.M_invMassB
iA := joint.M_invIA
iB := joint.M_invIB
vA := data.Velocities[joint.M_indexA].V
wA := data.Velocities[joint.M_indexA].W
vB := data.Velocities[joint.M_indexB].V
wB := data.Velocities[joint.M_indexB].W
// Solve spring constraint
{
Cdot := B2Vec2Dot(joint.M_ax, B2Vec2Sub(vB, vA)) + joint.M_sBx*wB - joint.M_sAx*wA
impulse := -joint.M_springMass * (Cdot + joint.M_bias + joint.M_gamma*joint.M_springImpulse)
joint.M_springImpulse += impulse
P := B2Vec2MulScalar(impulse, joint.M_ax)
LA := impulse * joint.M_sAx
LB := impulse * joint.M_sBx
vA.OperatorMinusInplace(B2Vec2MulScalar(mA, P))
wA -= iA * LA
vB.OperatorPlusInplace(B2Vec2MulScalar(mB, P))
wB += iB * LB
}
// Solve rotational motor constraint
{
Cdot := wB - wA - joint.M_motorSpeed
impulse := -joint.M_motorMass * Cdot
oldImpulse := joint.M_motorImpulse
maxImpulse := data.Step.Dt * joint.M_maxMotorTorque
joint.M_motorImpulse = B2FloatClamp(joint.M_motorImpulse+impulse, -maxImpulse, maxImpulse)
impulse = joint.M_motorImpulse - oldImpulse
wA -= iA * impulse
wB += iB * impulse
}
// Solve point to line constraint
{
Cdot := B2Vec2Dot(joint.M_ay, B2Vec2Sub(vB, vA)) + joint.M_sBy*wB - joint.M_sAy*wA
impulse := -joint.M_mass * Cdot
joint.M_impulse += impulse
P := B2Vec2MulScalar(impulse, joint.M_ay)
LA := impulse * joint.M_sAy
LB := impulse * joint.M_sBy
vA.OperatorMinusInplace(B2Vec2MulScalar(mA, P))
wA -= iA * LA
vB.OperatorPlusInplace(B2Vec2MulScalar(mB, P))
wB += iB * LB
}
data.Velocities[joint.M_indexA].V = vA
data.Velocities[joint.M_indexA].W = wA
data.Velocities[joint.M_indexB].V = vB
data.Velocities[joint.M_indexB].W = wB
}
func (joint *B2WheelJoint) SolvePositionConstraints(data B2SolverData) bool {
cA := data.Positions[joint.M_indexA].C
aA := data.Positions[joint.M_indexA].A
cB := data.Positions[joint.M_indexB].C
aB := data.Positions[joint.M_indexB].A
qA := MakeB2RotFromAngle(aA)
qB := MakeB2RotFromAngle(aB)
rA := B2RotVec2Mul(qA, B2Vec2Sub(joint.M_localAnchorA, joint.M_localCenterA))
rB := B2RotVec2Mul(qB, B2Vec2Sub(joint.M_localAnchorB, joint.M_localCenterB))
d := B2Vec2Sub(B2Vec2Add(B2Vec2Sub(cB, cA), rB), rA)
ay := B2RotVec2Mul(qA, joint.M_localYAxisA)
sAy := B2Vec2Cross(B2Vec2Add(d, rA), ay)
sBy := B2Vec2Cross(rB, ay)
C := B2Vec2Dot(d, ay)
k := joint.M_invMassA + joint.M_invMassB + joint.M_invIA*joint.M_sAy*joint.M_sAy + joint.M_invIB*joint.M_sBy*joint.M_sBy
impulse := 0.0
if k != 0.0 {
impulse = -C / k
} else {
impulse = 0.0
}
P := B2Vec2MulScalar(impulse, ay)
LA := impulse * sAy
LB := impulse * sBy
cA.OperatorMinusInplace(B2Vec2MulScalar(joint.M_invMassA, P))
aA -= joint.M_invIA * LA
cB.OperatorPlusInplace(B2Vec2MulScalar(joint.M_invMassB, P))
aB += joint.M_invIB * LB
data.Positions[joint.M_indexA].C = cA
data.Positions[joint.M_indexA].A = aA
data.Positions[joint.M_indexB].C = cB
data.Positions[joint.M_indexB].A = aB
return math.Abs(C) <= B2_linearSlop
}
func (joint B2WheelJoint) GetAnchorA() B2Vec2 {
return joint.M_bodyA.GetWorldPoint(joint.M_localAnchorA)
}
func (joint B2WheelJoint) GetAnchorB() B2Vec2 {
return joint.M_bodyB.GetWorldPoint(joint.M_localAnchorB)
}
func (joint B2WheelJoint) GetReactionForce(inv_dt float64) B2Vec2 {
return B2Vec2MulScalar(inv_dt, B2Vec2Add(B2Vec2MulScalar(joint.M_impulse, joint.M_ay), B2Vec2MulScalar(joint.M_springImpulse, joint.M_ax)))
}
func (joint B2WheelJoint) GetReactionTorque(inv_dt float64) float64 {
return inv_dt * joint.M_motorImpulse
}
func (joint B2WheelJoint) GetJointTranslation() float64 {
bA := joint.M_bodyA
bB := joint.M_bodyB
pA := bA.GetWorldPoint(joint.M_localAnchorA)
pB := bB.GetWorldPoint(joint.M_localAnchorB)
d := B2Vec2Sub(pB, pA)
axis := bA.GetWorldVector(joint.M_localXAxisA)
translation := B2Vec2Dot(d, axis)
return translation
}
func (joint B2WheelJoint) GetJointLinearSpeed() float64 {
bA := joint.M_bodyA
bB := joint.M_bodyB
rA := B2RotVec2Mul(bA.M_xf.Q, B2Vec2Sub(joint.M_localAnchorA, bA.M_sweep.LocalCenter))
rB := B2RotVec2Mul(bB.M_xf.Q, B2Vec2Sub(joint.M_localAnchorB, bB.M_sweep.LocalCenter))
p1 := B2Vec2Add(bA.M_sweep.C, rA)
p2 := B2Vec2Add(bB.M_sweep.C, rB)
d := B2Vec2Sub(p2, p1)
axis := B2RotVec2Mul(bA.M_xf.Q, joint.M_localXAxisA)
vA := bA.M_linearVelocity
vB := bB.M_linearVelocity
wA := bA.M_angularVelocity
wB := bB.M_angularVelocity
speed := B2Vec2Dot(d, B2Vec2CrossScalarVector(wA, axis)) + B2Vec2Dot(axis, B2Vec2Sub(B2Vec2Sub(B2Vec2Add(vB, B2Vec2CrossScalarVector(wB, rB)), vA), B2Vec2CrossScalarVector(wA, rA)))
return speed
}
func (joint B2WheelJoint) GetJointAngle() float64 {
bA := joint.M_bodyA
bB := joint.M_bodyB
return bB.M_sweep.A - bA.M_sweep.A
}
func (joint B2WheelJoint) GetJointAngularSpeed() float64 {
wA := joint.M_bodyA.M_angularVelocity
wB := joint.M_bodyB.M_angularVelocity
return wB - wA
}
func (joint B2WheelJoint) IsMotorEnabled() bool {
return joint.M_enableMotor
}
func (joint *B2WheelJoint) EnableMotor(flag bool) {
if flag != joint.M_enableMotor {
joint.M_bodyA.SetAwake(true)
joint.M_bodyB.SetAwake(true)
joint.M_enableMotor = flag
}
}
func (joint *B2WheelJoint) SetMotorSpeed(speed float64) {
if speed != joint.M_motorSpeed {
joint.M_bodyA.SetAwake(true)
joint.M_bodyB.SetAwake(true)
joint.M_motorSpeed = speed
}
}
func (joint *B2WheelJoint) SetMaxMotorTorque(torque float64) {
if torque != joint.M_maxMotorTorque {
joint.M_bodyA.SetAwake(true)
joint.M_bodyB.SetAwake(true)
joint.M_maxMotorTorque = torque
}
}
func (joint B2WheelJoint) GetMotorTorque(inv_dt float64) float64 {
return inv_dt * joint.M_motorImpulse
}
func (joint *B2WheelJoint) Dump() {
indexA := joint.M_bodyA.M_islandIndex
indexB := joint.M_bodyB.M_islandIndex
fmt.Printf(" b2WheelJointDef jd;\n")
fmt.Printf(" jd.bodyA = bodies[%d];\n", indexA)
fmt.Printf(" jd.bodyB = bodies[%d];\n", indexB)
fmt.Printf(" jd.collideConnected = bool(%v);\n", joint.M_collideConnected)
fmt.Printf(" jd.localAnchorA.Set(%.15f, %.15f);\n", joint.M_localAnchorA.X, joint.M_localAnchorA.Y)
fmt.Printf(" jd.localAnchorB.Set(%.15f, %.15f);\n", joint.M_localAnchorB.X, joint.M_localAnchorB.Y)
fmt.Printf(" jd.localAxisA.Set(%.15f, %.15f);\n", joint.M_localXAxisA.X, joint.M_localXAxisA.Y)
fmt.Printf(" jd.enableMotor = bool(%v);\n", joint.M_enableMotor)
fmt.Printf(" jd.motorSpeed = %.15f;\n", joint.M_motorSpeed)
fmt.Printf(" jd.maxMotorTorque = %.15f;\n", joint.M_maxMotorTorque)
fmt.Printf(" jd.frequencyHz = %.15f;\n", joint.M_frequencyHz)
fmt.Printf(" jd.dampingRatio = %.15f;\n", joint.M_dampingRatio)
fmt.Printf(" joints[%d] = m_world.CreateJoint(&jd);\n", joint.M_index)
} | DynamicsB2JointWheel.go | 0.913382 | 0.813275 | DynamicsB2JointWheel.go | starcoder |
package heatmap
import (
"context"
"runtime"
"github.com/vivint/rothko/draw"
)
// Options are the things you can specify to control the rendering of a
// heatmap.
type Options struct {
// Colors is the slice of colors to map the column data on to.
Colors []draw.Color
// Canvas to draw on to
Canvas draw.Canvas
// Map takes a value from the Data in the column, and expects it to be
// mapped to a value in [0,1] specifying the color.
Map func(float64) float64
}
// Heatmap is a struct that draws heatmaps from provided columns.
type Heatmap struct {
opts Options
m *draw.RGB // possibly type asserted
color_scale float64
width, height int
}
// New returns a new Heatmap using the given options.
func New(opts Options) *Heatmap {
m, _ := opts.Canvas.(*draw.RGB)
width, height := opts.Canvas.Size()
return &Heatmap{
opts: opts,
m: m,
color_scale: float64(len(opts.Colors) - 1),
width: width,
height: height,
}
}
// Draw writes the column to the canvas.
func (d *Heatmap) Draw(ctx context.Context, col draw.Column) {
last_index := -1
last_color := d.opts.Colors[0]
index_scale := float64(len(col.Data)-1) / float64(d.height-1)
m := d.m
for y := 0; y < d.height; y++ {
// TODO(jeff): truncating might not work. we can also perhaps
// invert this computation to give us the number of pixels
// before we get to the next index directly.
index := int(float64(y) * index_scale)
// figure out the color if it's different from the last data index
if index != last_index {
color_index := int(d.opts.Map(col.Data[index]) * d.color_scale)
last_color = d.opts.Colors[color_index]
last_index = index
}
if m != nil {
row := (d.height - 1 - y + m.Y) * m.Stride
low := row + 4*(col.X+m.X)
high := low + 4*col.W
if high > len(m.Pix) {
high = len(m.Pix)
}
// reslicing in gopherjs always allocates a slice structure. so
// since it doesn't elide bounds checks, we write it this way even
// though it'd be slower if compiled by gc.
if runtime.GOARCH == "js" {
for offset := low; offset < high; offset += 4 {
m.Pix[offset+0] = last_color.R
m.Pix[offset+1] = last_color.G
m.Pix[offset+2] = last_color.B
m.Pix[offset+3] = 255
}
} else {
pix := m.Pix[low:high]
for len(pix) >= 4 {
pix[0] = last_color.R
pix[1] = last_color.G
pix[2] = last_color.B
pix[3] = 255
pix = pix[4:]
}
}
} else {
x1 := col.X + col.W
for x := col.X; x < x1 && x < d.width; x++ {
d.opts.Canvas.Set(x, y, last_color)
}
}
}
} | draw/heatmap/heatmap.go | 0.654453 | 0.494141 | heatmap.go | starcoder |
package toolbox
import (
"fmt"
"reflect"
"strconv"
"strings"
"time"
)
//DefaultDateLayout is set to 2006-01-02 15:04:05.000
var DefaultDateLayout = "2006-01-02 15:04:05.000"
//AsString converts an input to string.
func AsString(input interface{}) string {
switch inputValue := input.(type) {
case string:
return inputValue
case []byte:
return string(inputValue)
}
reflectValue := reflect.ValueOf(input)
if reflectValue.Kind() == reflect.Ptr {
reflectValue = reflectValue.Elem()
}
switch reflectValue.Kind() {
case reflect.Bool:
return strconv.FormatBool(reflectValue.Bool())
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return strconv.FormatInt(reflectValue.Int(), 10)
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
return strconv.FormatUint(reflectValue.Uint(), 10)
case reflect.Float64:
return strconv.FormatFloat(reflectValue.Float(), 'g', -1, 64)
case reflect.Float32:
return strconv.FormatFloat(reflectValue.Float(), 'g', -1, 32)
}
return fmt.Sprintf("%v", input)
}
//CanConvertToFloat checkis if float conversion is possible.
func CanConvertToFloat(value interface{}) bool {
if _, ok := value.(float64); ok {
return true
}
_, err := strconv.ParseFloat(AsString(value), 64)
return err == nil
}
//AsFloat converts an input to float.
func AsFloat(value interface{}) float64 {
if floatValue, ok := value.(float64); ok {
return floatValue
}
valueAsString := AsString(value)
if result, err := strconv.ParseFloat(valueAsString, 64); err == nil {
return result
}
return 0
}
//AsBoolean converts an input to bool.
func AsBoolean(value interface{}) bool {
if boolValue, ok := value.(bool); ok {
return boolValue
}
valueAsString := AsString(value)
if result, err := strconv.ParseBool(valueAsString); err == nil {
return result
}
return false
}
//CanConvertToInt returns true if an input can be converted to int value.
func CanConvertToInt(value interface{}) bool {
if _, ok := value.(int); ok {
return true
}
valueAsString := AsString(value)
if _, err := strconv.ParseInt(valueAsString, 10, 64); err == nil {
return true
}
return false
}
//AsInt converts an input to int.
func AsInt(value interface{}) int {
if intValue, ok := value.(int); ok {
return intValue
}
if floatValue, ok := value.(float64); ok {
return int(floatValue)
}
valueAsString := AsString(value)
if result, err := strconv.ParseInt(valueAsString, 10, 64); err == nil {
return int(result)
}
return 0
}
//AsTime converts an input to time, it takes time input, dateLaout as parameters.
func AsTime(value interface{}, dateLayout string) *time.Time {
if timeValue, ok := value.(time.Time); ok {
return &timeValue
}
if CanConvertToFloat(value) {
unixTime := int(AsFloat(value))
timeValue := time.Unix(int64(unixTime), 0)
return &timeValue
}
timeValue, err := ParseTime(AsString(value), dateLayout)
if err != nil {
return nil
}
return &timeValue
}
//DiscoverValueAndKind discovers input kind, it applies checks of the following types: int, float, bool, string
func DiscoverValueAndKind(input string) (interface{}, reflect.Kind) {
if len(input) == 0 {
return nil, reflect.Invalid
}
if strings.Contains(input, ".") {
if floatValue, err := strconv.ParseFloat(input, 64); err == nil {
return floatValue, reflect.Float64
}
}
if intValue, err := strconv.ParseInt(input, 10, 64); err == nil {
return int(intValue), reflect.Int
} else if strings.ToLower(input) == "true" {
return true, reflect.Bool
} else if strings.ToLower(input) == "false" {
return false, reflect.Bool
}
return input, reflect.String
}
//DiscoverCollectionValuesAndKind discovers passed in slice item kind, and returns slice of values converted to discovered type.
//It tries the following kind int, float, bool, string
func DiscoverCollectionValuesAndKind(values interface{}) ([]interface{}, reflect.Kind) {
var candidateKind = reflect.Int
var result = make([]interface{}, 0)
ProcessSlice(values, func(value interface{}) bool {
stringValue := strings.ToLower(AsString(value))
switch candidateKind {
case reflect.String:
return false
case reflect.Int:
if !strings.Contains(stringValue, ".") && CanConvertToInt(value) {
return true
}
candidateKind = reflect.Float64
fallthrough
case reflect.Float64:
if CanConvertToFloat(value) {
return true
}
candidateKind = reflect.Bool
fallthrough
case reflect.Bool:
if stringValue == "true" || stringValue == "false" {
return true
}
candidateKind = reflect.String
}
return true
})
ProcessSlice(values, func(value interface{}) bool {
switch candidateKind {
case reflect.Float64:
result = append(result, AsFloat(value))
case reflect.Int:
result = append(result, AsInt(value))
case reflect.Bool:
result = append(result, AsBoolean(value))
default:
result = append(result, AsString(value))
}
return true
})
return result, candidateKind
}
//UnwrapValue returns value
func UnwrapValue(value *reflect.Value) interface{} {
return value.Interface()
}
//NewBytes copies from input
func NewBytes(input []byte) []byte {
if input != nil {
var result = make([]byte, len(input))
copy(result, input)
return result
}
return nil
}
//ParseTime parses time, adjusting date layout to length of input
func ParseTime(input, layout string) (time.Time, error) {
if len(layout) == 0 {
layout = DefaultDateLayout
} //GetFieldValue returns field value
lastPosition := len(input)
if lastPosition >= len(layout) {
lastPosition = len(layout)
}
layout = layout[0:lastPosition]
return time.Parse(layout, input)
}
//Converter represets data converter, it converts incompatibe data structure, like map and struct, string and time, *string to string, etc.
type Converter struct {
DataLayout string
MappedKeyTag string
}
func (c *Converter) assignConvertedMap(target, input interface{}, targetIndirectValue reflect.Value, targetIndirectPointerType reflect.Type) error {
mapType := DiscoverTypeByKind(target, reflect.Map)
mapPointer := reflect.New(mapType)
mapValueType := mapType.Elem()
keyKeyType := mapType.Key()
newMap := mapPointer.Elem()
newMap.Set(reflect.MakeMap(mapType))
var err error
ProcessMap(input, func(key, value interface{}) bool {
mapValueType = reflect.TypeOf(value)
targetMapValuePointer := reflect.New(mapValueType)
err = c.AssignConverted(targetMapValuePointer.Interface(), value)
if err != nil {
err = fmt.Errorf("Failed to assigned converted map value %v to %v due to %v", input, target, err)
return false
}
targetMapKeyPointer := reflect.New(keyKeyType)
err = c.AssignConverted(targetMapKeyPointer.Interface(), key)
if err != nil {
err = fmt.Errorf("Failed to assigned converted map key %v to %v due to %v", input, target, err)
return false
}
newMap.SetMapIndex(targetMapKeyPointer.Elem(), targetMapValuePointer.Elem())
return true
})
if targetIndirectPointerType.Kind() == reflect.Map {
targetIndirectValue.Set(mapPointer)
} else {
targetIndirectValue.Set(newMap)
}
return err
}
func (c *Converter) assignConvertedSlice(target, input interface{}, targetIndirectValue reflect.Value, targetIndirectPointerType reflect.Type) error {
sliceType := DiscoverTypeByKind(target, reflect.Slice)
slicePointer := reflect.New(sliceType)
slice := slicePointer.Elem()
componentType := DiscoverComponentType(target)
var err error
ProcessSlice(input, func(item interface{}) bool {
targetComponentPointer := reflect.New(componentType)
err = c.AssignConverted(targetComponentPointer.Interface(), item)
if err != nil {
err = fmt.Errorf("Failed to convert slice tiem %v to %v due to %v", item, targetComponentPointer.Interface(), err)
return false
}
slice.Set(reflect.Append(slice, targetComponentPointer.Elem()))
return true
})
if targetIndirectPointerType.Kind() == reflect.Slice {
targetIndirectValue.Set(slicePointer)
} else {
targetIndirectValue.Set(slice)
}
return err
}
func (c *Converter) assignConvertedStruct(target interface{}, inputMap map[string]interface{}, targetIndirectValue reflect.Value, targetIndirectPointerType reflect.Type) error {
newStructPointer := reflect.New(targetIndirectValue.Type())
newStruct := newStructPointer.Elem()
fieldsMapping := NewFieldSettingByKey(newStructPointer.Interface(), c.MappedKeyTag)
for key, value := range inputMap {
mapping, found := fieldsMapping[strings.ToLower(key)];
if found {
fieldName := mapping["fieldName"]
field := newStruct.FieldByName(fieldName)
if HasTimeLayout(mapping) {
previousLayout := c.DataLayout
c.DataLayout = GetTimeLayout(mapping)
err := c.AssignConverted(field.Addr().Interface(), value)
if err != nil {
return fmt.Errorf("Failed to convert %v to %v due to %v", value, field, err)
}
c.DataLayout = previousLayout
} else {
err := c.AssignConverted(field.Addr().Interface(), value)
if err != nil {
return fmt.Errorf("Failed to convert %v to %v due to %v", value, field, err)
}
}
}
}
if targetIndirectPointerType.Kind() == reflect.Slice {
targetIndirectValue.Set(newStructPointer)
} else {
targetIndirectValue.Set(newStruct)
}
return nil
}
//AssignConverted assign to the target input, target needs to be pointer, input has to be convertible or compatible type
func (c *Converter) AssignConverted(target, input interface{}) error {
if target == nil {
return fmt.Errorf("destinationPointer was nil %v %v", target, input)
}
if input == nil {
return nil
}
switch targetValuePointer := target.(type) {
case *string:
switch inputValue := input.(type) {
case string:
*targetValuePointer = inputValue
return nil
case *string:
*targetValuePointer = *inputValue
return nil
case []byte:
*targetValuePointer = string(inputValue)
return nil
case *[]byte:
*targetValuePointer = string(NewBytes(*inputValue))
return nil
default:
*targetValuePointer = AsString(input)
return nil
}
case **string:
switch inputValue := input.(type) {
case string:
*targetValuePointer = &inputValue
return nil
case *string:
*targetValuePointer = inputValue
return nil
case []byte:
var stringSourceValue = string(inputValue)
*targetValuePointer = &stringSourceValue
return nil
case *[]byte:
var stringSourceValue = string(NewBytes(*inputValue))
*targetValuePointer = &stringSourceValue
return nil
default:
stringSourceValue := AsString(input)
*targetValuePointer = &stringSourceValue
return nil
}
case *bool:
switch inputValue := input.(type) {
case bool:
*targetValuePointer = inputValue
return nil
case *bool:
*targetValuePointer = *inputValue
return nil
case int:
*targetValuePointer = inputValue != 0
return nil
case string:
boolValue, err := strconv.ParseBool(inputValue)
if err != nil {
return err
}
*targetValuePointer = boolValue
return nil
case *string:
boolValue, err := strconv.ParseBool(*inputValue)
if err != nil {
return err
}
*targetValuePointer = boolValue
return nil
}
case **bool:
switch inputValue := input.(type) {
case bool:
*targetValuePointer = &inputValue
return nil
case *bool:
*targetValuePointer = inputValue
return nil
case int:
boolValue := inputValue != 0
*targetValuePointer = &boolValue
return nil
case string:
boolValue, err := strconv.ParseBool(inputValue)
if err != nil {
return err
}
*targetValuePointer = &boolValue
return nil
case *string:
boolValue, err := strconv.ParseBool(*inputValue)
if err != nil {
return err
}
*targetValuePointer = &boolValue
return nil
}
case *[]byte:
switch inputValue := input.(type) {
case []byte:
*targetValuePointer = inputValue
return nil
case *[]byte:
*targetValuePointer = *inputValue
return nil
case string:
*targetValuePointer = []byte(inputValue)
return nil
case *string:
var stringValue = *inputValue
*targetValuePointer = []byte(stringValue)
return nil
}
case **[]byte:
switch inputValue := input.(type) {
case []byte:
bytes := NewBytes(inputValue)
*targetValuePointer = &bytes
return nil
case *[]byte:
bytes := NewBytes(*inputValue)
*targetValuePointer = &bytes
return nil
case string:
bytes := []byte(inputValue)
*targetValuePointer = &bytes
return nil
case *string:
bytes := []byte(*inputValue)
*targetValuePointer = &bytes
return nil
}
case *int, *int8, *int16, *int32, *int64:
directValue := reflect.Indirect(reflect.ValueOf(targetValuePointer))
inputValue := reflect.ValueOf(input)
if inputValue.Kind() == reflect.Ptr {
inputValue = inputValue.Elem()
}
stringValue := AsString(inputValue.Interface())
value, err := strconv.ParseInt(stringValue, 10, directValue.Type().Bits())
if err != nil {
return err
}
directValue.SetInt(value)
return nil
case **int, **int8, **int16, **int32, **int64:
directType := reflect.TypeOf(targetValuePointer).Elem().Elem()
inputValue := reflect.ValueOf(input)
if inputValue.Kind() == reflect.Ptr {
inputValue = inputValue.Elem()
}
stringValue := AsString(inputValue.Interface())
value, err := strconv.ParseInt(stringValue, 10, directType.Bits())
if err != nil {
return err
}
reflect.ValueOf(targetValuePointer).Elem().Set(reflect.ValueOf(&value))
return nil
case *uint, *uint8, *uint16, *uint32, *uint64:
directValue := reflect.Indirect(reflect.ValueOf(targetValuePointer))
inputValue := reflect.ValueOf(input)
if inputValue.Kind() == reflect.Ptr {
inputValue = inputValue.Elem()
}
stringValue := AsString(inputValue.Interface())
value, err := strconv.ParseUint(stringValue, 10, directValue.Type().Bits())
if err != nil {
return err
}
directValue.SetUint(value)
return nil
case **uint, **uint8, **uint16, **uint32, **uint64:
directType := reflect.TypeOf(targetValuePointer).Elem().Elem()
inputValue := reflect.ValueOf(input)
if inputValue.Kind() == reflect.Ptr {
inputValue = inputValue.Elem()
}
stringValue := AsString(inputValue.Interface())
value, err := strconv.ParseUint(stringValue, 10, directType.Bits())
if err != nil {
return err
}
reflect.ValueOf(targetValuePointer).Elem().Set(reflect.ValueOf(&value))
return nil
case *float32, *float64:
directValue := reflect.Indirect(reflect.ValueOf(targetValuePointer))
inputValue := reflect.ValueOf(input)
if inputValue.Kind() == reflect.Ptr {
inputValue = inputValue.Elem()
}
stringValue := AsString(inputValue.Interface())
value, err := strconv.ParseFloat(stringValue, directValue.Type().Bits())
if err != nil {
return err
}
directValue.SetFloat(value)
return nil
case **float32, **float64:
directType := reflect.TypeOf(targetValuePointer).Elem().Elem()
inputValue := reflect.ValueOf(input)
if inputValue.Kind() == reflect.Ptr {
inputValue = inputValue.Elem()
}
stringValue := AsString(inputValue.Interface())
value, err := strconv.ParseFloat(stringValue, directType.Bits())
if err != nil {
return err
}
reflect.ValueOf(targetValuePointer).Elem().Set(reflect.ValueOf(&value))
return nil
case *time.Time:
switch inputValue := input.(type) {
case string:
timeValue := AsTime(inputValue, c.DataLayout)
if timeValue == nil {
_, err := time.Parse(c.DataLayout, inputValue)
return err
}
*targetValuePointer = *timeValue
return nil
case *string:
timeValue := AsTime(inputValue, c.DataLayout)
if timeValue == nil {
_, err := time.Parse(c.DataLayout, *inputValue)
return err
}
*targetValuePointer = *timeValue
return nil
case int, int64, uint, uint64, float32, float64, *int, *int64, *uint, *uint64, *float32, *float64:
intValue := int(AsFloat(inputValue))
timeValue := time.Unix(int64(intValue), 0)
*targetValuePointer = timeValue
return nil
}
case **time.Time:
switch inputValue := input.(type) {
case string:
timeValue := AsTime(inputValue, c.DataLayout)
if timeValue == nil {
_, err := time.Parse(c.DataLayout, inputValue)
return err
}
*targetValuePointer = timeValue
return nil
case *string:
timeValue := AsTime(inputValue, c.DataLayout)
if timeValue == nil {
_, err := time.Parse(c.DataLayout, *inputValue)
return err
}
*targetValuePointer = timeValue
return nil
case int, int64, uint, uint64, float32, float64, *int, *int64, *uint, *uint64, *float32, *float64:
intValue := int(AsFloat(inputValue))
timeValue := time.Unix(int64(intValue), 0)
*targetValuePointer = &timeValue
return nil
}
case *interface{}:
(*targetValuePointer) = input
return nil
case **interface{}:
(*targetValuePointer) = &input
return nil
}
inputValue := reflect.ValueOf(input)
if input == nil || !inputValue.IsValid() || (inputValue.CanSet() && inputValue.IsNil()) {
return nil
}
targetIndirectValue := reflect.Indirect(reflect.ValueOf(target))
if inputValue.IsValid() && inputValue.Type().AssignableTo(reflect.TypeOf(target)) {
targetIndirectValue.Set(inputValue.Elem())
return nil
}
var targetIndirectPointerType = reflect.TypeOf(target).Elem()
if targetIndirectPointerType.Kind() == reflect.Ptr || targetIndirectPointerType.Kind() == reflect.Slice || targetIndirectPointerType.Kind() == reflect.Map {
targetIndirectPointerType = targetIndirectPointerType.Elem()
}
if targetIndirectValue.Kind() == reflect.Slice || targetIndirectPointerType.Kind() == reflect.Slice {
if inputValue.Kind() == reflect.Slice {
return c.assignConvertedSlice(target, input, targetIndirectValue, targetIndirectPointerType)
}
}
if targetIndirectValue.Kind() == reflect.Map || targetIndirectPointerType.Kind() == reflect.Map {
if inputValue.Kind() == reflect.Map {
return c.assignConvertedMap(target, input, targetIndirectValue, targetIndirectPointerType)
}
} else if targetIndirectValue.Kind() == reflect.Struct {
if inputMap, ok := input.(map[string]interface{}); ok {
return c.assignConvertedStruct(target, inputMap, targetIndirectValue, targetIndirectPointerType)
}
} else if targetIndirectPointerType.Kind() == reflect.Struct {
structPointer := reflect.New(targetIndirectPointerType)
if inputMap, ok := input.(map[string]interface{}); ok {
err := c.assignConvertedStruct(target, inputMap, structPointer.Elem(), targetIndirectPointerType)
if err != nil {
return err
}
targetIndirectValue.Set(structPointer)
return nil
}
}
if inputValue.IsValid() && inputValue.Type().AssignableTo(targetIndirectValue.Type()) {
targetIndirectValue.Set(inputValue)
return nil
}
if inputValue.IsValid() && inputValue.Type().ConvertibleTo(targetIndirectValue.Type()) {
converted := inputValue.Convert(targetIndirectValue.Type())
targetIndirectValue.Set(converted)
return nil
}
return fmt.Errorf("Unable to convert type %T into type %T", input, target)
}
//NewColumnConverter create a new converter, that has abbility to convert map to struct using column mapping
func NewColumnConverter(dataFormat string) *Converter {
return &Converter{dataFormat, "column"}
} | converter.go | 0.679391 | 0.402069 | converter.go | starcoder |
package models
import (
i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91 "github.com/microsoft/kiota-abstractions-go/serialization"
)
// SimulationReport
type SimulationReport struct {
// Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well.
additionalData map[string]interface{}
// Overview of an attack simulation and training campaign.
overview SimulationReportOverviewable
// Represents users of a tenant and their online actions in an attack simulation and training campaign.
simulationUsers []UserSimulationDetailsable
}
// NewSimulationReport instantiates a new simulationReport and sets the default values.
func NewSimulationReport()(*SimulationReport) {
m := &SimulationReport{
}
m.SetAdditionalData(make(map[string]interface{}));
return m
}
// CreateSimulationReportFromDiscriminatorValue creates a new instance of the appropriate class based on discriminator value
func CreateSimulationReportFromDiscriminatorValue(parseNode i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.ParseNode)(i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.Parsable, error) {
return NewSimulationReport(), nil
}
// GetAdditionalData gets the additionalData property value. Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well.
func (m *SimulationReport) GetAdditionalData()(map[string]interface{}) {
if m == nil {
return nil
} else {
return m.additionalData
}
}
// GetFieldDeserializers the deserialization information for the current model
func (m *SimulationReport) GetFieldDeserializers()(map[string]func(i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.ParseNode)(error)) {
res := make(map[string]func(i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.ParseNode)(error))
res["overview"] = func (n i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.ParseNode) error {
val, err := n.GetObjectValue(CreateSimulationReportOverviewFromDiscriminatorValue)
if err != nil {
return err
}
if val != nil {
m.SetOverview(val.(SimulationReportOverviewable))
}
return nil
}
res["simulationUsers"] = func (n i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.ParseNode) error {
val, err := n.GetCollectionOfObjectValues(CreateUserSimulationDetailsFromDiscriminatorValue)
if err != nil {
return err
}
if val != nil {
res := make([]UserSimulationDetailsable, len(val))
for i, v := range val {
res[i] = v.(UserSimulationDetailsable)
}
m.SetSimulationUsers(res)
}
return nil
}
return res
}
// GetOverview gets the overview property value. Overview of an attack simulation and training campaign.
func (m *SimulationReport) GetOverview()(SimulationReportOverviewable) {
if m == nil {
return nil
} else {
return m.overview
}
}
// GetSimulationUsers gets the simulationUsers property value. Represents users of a tenant and their online actions in an attack simulation and training campaign.
func (m *SimulationReport) GetSimulationUsers()([]UserSimulationDetailsable) {
if m == nil {
return nil
} else {
return m.simulationUsers
}
}
// Serialize serializes information the current object
func (m *SimulationReport) Serialize(writer i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.SerializationWriter)(error) {
{
err := writer.WriteObjectValue("overview", m.GetOverview())
if err != nil {
return err
}
}
if m.GetSimulationUsers() != nil {
cast := make([]i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.Parsable, len(m.GetSimulationUsers()))
for i, v := range m.GetSimulationUsers() {
cast[i] = v.(i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.Parsable)
}
err := writer.WriteCollectionOfObjectValues("simulationUsers", cast)
if err != nil {
return err
}
}
{
err := writer.WriteAdditionalData(m.GetAdditionalData())
if err != nil {
return err
}
}
return nil
}
// SetAdditionalData sets the additionalData property value. Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well.
func (m *SimulationReport) SetAdditionalData(value map[string]interface{})() {
if m != nil {
m.additionalData = value
}
}
// SetOverview sets the overview property value. Overview of an attack simulation and training campaign.
func (m *SimulationReport) SetOverview(value SimulationReportOverviewable)() {
if m != nil {
m.overview = value
}
}
// SetSimulationUsers sets the simulationUsers property value. Represents users of a tenant and their online actions in an attack simulation and training campaign.
func (m *SimulationReport) SetSimulationUsers(value []UserSimulationDetailsable)() {
if m != nil {
m.simulationUsers = value
}
} | models/simulation_report.go | 0.649801 | 0.533944 | simulation_report.go | starcoder |
package main
import (
"fmt"
"github.com/jeffwilliams/squarify"
"io"
"os"
)
func main() {
// Options modifying Squarify behaviour.
opt := squarify.Options{
// Left, Right, and Bottom margin of 5, and a Top margin of 30.
Margins: &squarify.Margins{5, 5, 30, 5},
// Sort biggest to smallest
Sort: true,
}
// Define the size of the output: 800x800
canvas := squarify.Rect{W: 800, H: 800}
// Run the Squarify function on our sample tree to get a slice of Blocks we can render,
// and metadata for each block
blocks, meta := squarify.Squarify(sampleTree(), canvas, opt)
// Output the Blocks as an SVG image to stdout (redirect to a file to save)
makeSvg(blocks, meta, canvas, os.Stdout)
}
// Our implementation of the TreeMap.
type TreeMap struct {
children []TreeMap
size float64
label string
}
// Size implements a required method of the TreeSizer interface needed by Squarify.
func (t TreeMap) Size() float64 {
return t.size
}
// NumChildren implements a required method of the TreeSizer interface needed by Squarify.
func (t TreeMap) NumChildren() int {
return len(t.children)
}
// Child implements a required method of the TreeSizer interface needed by Squarify.
func (t TreeMap) Child(i int) squarify.TreeSizer {
return squarify.TreeSizer(t.children[i])
}
// setSize sets the size of the TreeMap node to the sum of the sizes of it's children plus the passed size.
// This is a helper function for sampleTree below.
func (t *TreeMap) setSize(size float64) {
t.size = size
for _, c := range t.children {
t.size += c.size
}
}
// sampleTree builds the TreeMap we will output.
func sampleTree() TreeMap {
a := TreeMap{label: "a (40)", size: 40}
b := TreeMap{label: "b (30)", size: 30}
c := TreeMap{label: "c (10)", children: []TreeMap{a, b}}
c.setSize(10)
d := TreeMap{label: "d (10)", size: 10}
e := TreeMap{label: "e (20)", size: 20}
f := TreeMap{label: "f (15)", size: 15}
g := TreeMap{label: "g (15)", size: 15}
h := TreeMap{label: "h (15)", size: 15}
i := TreeMap{label: "i (30)", size: 30}
j := TreeMap{label: "j (0)", children: []TreeMap{d, e, f, g, h, i}}
j.setSize(0)
k := TreeMap{label: "k (10)", size: 10}
l := TreeMap{label: "l (20)", size: 20}
m := TreeMap{label: "m (12)", size: 15}
n := TreeMap{label: "n (16)", size: 15}
o := TreeMap{label: "o (15)", size: 15}
p := TreeMap{label: "p (15)", children: []TreeMap{k, l, m, n, o}}
p.setSize(15)
root := TreeMap{label: "root (0)", children: []TreeMap{c, j, p}}
root.setSize(0)
return root
}
// colors we will use to fill the Blocks at different depths.
var colors []string = []string{"588C7E", "F2E394", "F2AE72", "D96459", "8C4646"}
func color(depth int) string {
return colors[(depth+2)%len(colors)]
}
// makeSvg outputs an SVG image from the passed blocks and meta. The size of the image is the size of canvas,
// and the SVG is output to the writer w.
func makeSvg(blocks []squarify.Block, meta []squarify.Meta, canvas squarify.Rect, w io.Writer) {
fmt.Fprintf(w, "<svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" width=\"%f\" height=\"%f\">\n",
canvas.W, canvas.H)
for i, b := range blocks {
fmt.Fprintf(w, " <rect x=\"%f\" y=\"%f\" width=\"%f\" height=\"%f\" style=\"fill: #%s;stroke-width: 1;stroke: #000000; font-family: verdana, bitstream vera sans, sans\"/>\n",
b.X, b.Y, b.W, b.H, color(meta[i].Depth))
if b.TreeSizer != nil {
label := b.TreeSizer.(TreeMap).label
fmt.Fprintf(w, " <text x=\"%f\" y=\"%f\" style=\"font-size:20px\">%s</text>\n", b.X+5, b.Y+20, label)
}
}
fmt.Fprintf(w, "</svg>\n")
} | examples/svg/svg.go | 0.697197 | 0.476519 | svg.go | starcoder |
package vm
//go:generate stringer -type=Opcode
// Opcode is an single operational instruction for the GO NEO virtual machine.
type Opcode byte
// List of supported opcodes.
const (
// Constants
Opush0 Opcode = 0x00 // An empty array of bytes is pushed onto the stack.
Opushf Opcode = Opush0
Opushbytes1 Opcode = 0x01 // 0x01-0x4B The next opcode bytes is data to be pushed onto the stack
Opushbytes75 Opcode = 0x4B
Opushdata1 Opcode = 0x4C // The next byte contains the number of bytes to be pushed onto the stack.
Opushdata2 Opcode = 0x4D // The next two bytes contain the number of bytes to be pushed onto the stack.
Opushdata4 Opcode = 0x4E // The next four bytes contain the number of bytes to be pushed onto the stack.
Opushm1 Opcode = 0x4F // The number -1 is pushed onto the stack.
Opush1 Opcode = 0x51
Opusht Opcode = Opush1
Opush2 Opcode = 0x52 // The number 2 is pushed onto the stack.
Opush3 Opcode = 0x53 // The number 3 is pushed onto the stack.
Opush4 Opcode = 0x54 // The number 4 is pushed onto the stack.
Opush5 Opcode = 0x55 // The number 5 is pushed onto the stack.
Opush6 Opcode = 0x56 // The number 6 is pushed onto the stack.
Opush7 Opcode = 0x57 // The number 7 is pushed onto the stack.
Opush8 Opcode = 0x58 // The number 8 is pushed onto the stack.
Opush9 Opcode = 0x59 // The number 9 is pushed onto the stack.
Opush10 Opcode = 0x5A // The number 10 is pushed onto the stack.
Opush11 Opcode = 0x5B // The number 11 is pushed onto the stack.
Opush12 Opcode = 0x5C // The number 12 is pushed onto the stack.
Opush13 Opcode = 0x5D // The number 13 is pushed onto the stack.
Opush14 Opcode = 0x5E // The number 14 is pushed onto the stack.
Opush15 Opcode = 0x5F // The number 15 is pushed onto the stack.
Opush16 Opcode = 0x60 // The number 16 is pushed onto the stack.
// Flow control
Onop Opcode = 0x61 // No operation.
Ojmp Opcode = 0x62
Ojmpif Opcode = 0x63
Ojmpifnot Opcode = 0x64
Ocall Opcode = 0x65
Oret Opcode = 0x66
Oappcall Opcode = 0x67
Osyscall Opcode = 0x68
Otailcall Opcode = 0x69
// The stack
Odupfromaltstack Opcode = 0x6A
Otoaltstack Opcode = 0x6B // Puts the input onto the top of the alt stack. Removes it from the main stack.
Ofromaltstack Opcode = 0x6C // Puts the input onto the top of the main stack. Removes it from the alt stack.
Oxdrop Opcode = 0x6D
Oxswap Opcode = 0x72
Oxtuck Opcode = 0x73
Odepth Opcode = 0x74 // Puts the number of stack items onto the stack.
Odrop Opcode = 0x75 // Removes the top stack item.
Odup Opcode = 0x76 // Duplicates the top stack item.
Onip Opcode = 0x77 // Removes the second-to-top stack item.
Oover Opcode = 0x78 // Copies the second-to-top stack item to the top.
Opick Opcode = 0x79 // The item n back in the stack is copied to the top.
Oroll Opcode = 0x7A // The item n back in the stack is moved to the top.
Orot Opcode = 0x7B // The top three items on the stack are rotated to the left.
Oswap Opcode = 0x7C // The top two items on the stack are swapped.
Otuck Opcode = 0x7D // The item at the top of the stack is copied and inserted before the second-to-top item.
// Splice
Ocat Opcode = 0x7E // Concatenates two strings.
Osubstr Opcode = 0x7F // Returns a section of a string.
Oleft Opcode = 0x80 // Keeps only characters left of the specified point in a string.
Oright Opcode = 0x81 // Keeps only characters right of the specified point in a string.
Osize Opcode = 0x82 // Returns the length of the input string.
// Bitwise logic
Oinvert Opcode = 0x83 // Flips all of the bits in the input.
Oand Opcode = 0x84 // Boolean and between each bit in the inputs.
Oor Opcode = 0x85 // Boolean or between each bit in the inputs.
Oxor Opcode = 0x86 // Boolean exclusive or between each bit in the inputs.
Oequal Opcode = 0x87 // Returns 1 if the inputs are exactly equal, 0 otherwise.
// Arithmetic
// Note: Arithmetic inputs are limited to signed 32-bit integers, but may overflow their output.
Oinc Opcode = 0x8B // 1 is added to the input.
Odec Opcode = 0x8C // 1 is subtracted from the input.
Osign Opcode = 0x8D
Onegate Opcode = 0x8F // The sign of the input is flipped.
Oabs Opcode = 0x90 // The input is made positive.
Onot Opcode = 0x91 // If the input is 0 or 1, it is flipped. Otherwise the output will be 0.
Onz Opcode = 0x92 // Returns 0 if the input is 0. 1 otherwise.
Oadd Opcode = 0x93 // a is added to b.
Osub Opcode = 0x94 // b is subtracted from a.
Omul Opcode = 0x95 // a is multiplied by b.
Odiv Opcode = 0x96 // a is divided by b.
Omod Opcode = 0x97 // Returns the remainder after dividing a by b.
Oshl Opcode = 0x98 // Shifts a left b bits, preserving sign.
Oshr Opcode = 0x99 // Shifts a right b bits, preserving sign.
Obooland Opcode = 0x9A // If both a and b are not 0, the output is 1. Otherwise 0.
Oboolor Opcode = 0x9B // If a or b is not 0, the output is 1. Otherwise 0.
Onumequal Opcode = 0x9C // Returns 1 if the numbers are equal, 0 otherwise.
Onumnotequal Opcode = 0x9E // Returns 1 if the numbers are not equal, 0 otherwise.
Olt Opcode = 0x9F // Returns 1 if a is less than b, 0 otherwise.
Ogt Opcode = 0xA0 // Returns 1 if a is greater than b, 0 otherwise.
Olte Opcode = 0xA1 // Returns 1 if a is less than or equal to b, 0 otherwise.
Ogte Opcode = 0xA2 // Returns 1 if a is greater than or equal to b, 0 otherwise.
Omin Opcode = 0xA3 // Returns the smaller of a and b.
Omax Opcode = 0xA4 // Returns the larger of a and b.
Owithin Opcode = 0xA5 // Returns 1 if x is within the specified range (left-inclusive), 0 otherwise.
// Crypto
Osha1 Opcode = 0xA7 // The input is hashed using SHA-1.
Osha256 Opcode = 0xA8 // The input is hashed using SHA-256.
Ohash160 Opcode = 0xA9
Ohash256 Opcode = 0xAA
Ochecksig Opcode = 0xAC
Ocheckmultisig Opcode = 0xAE
// array
Oarraysize Opcode = 0xC0
Opack Opcode = 0xC1
Ounpack Opcode = 0xC2
Opickitem Opcode = 0xC3
Osetitem Opcode = 0xC4
Onewarray Opcode = 0xC5 // Pops size from stack and creates a new array with that size, and pushes the array into the stack
Onewstruct Opcode = 0xC6
Oappend Opcode = 0xC8
Oreverse Opcode = 0xC9
Oremove Opcode = 0xCA
// exceptions
Othrow Opcode = 0xF0
Othrowifnot Opcode = 0xF1
) | vendor/github.com/CityOfZion/neo-go/pkg/vm/opcode.go | 0.503906 | 0.5867 | opcode.go | starcoder |
package ipx
import (
"fmt"
"math/bits"
"net"
u128 "github.com/Pilatuz/bigx/v2/uint128"
)
// SummarizeRange returns a series of networks which cover the range
// between the first and last addresses, inclusive.
func SummarizeRange(first, last net.IP) ([]*net.IPNet, error) {
// first IPv4 or IPv6
var firstV4, firstV6 net.IP
switch len(first) {
case net.IPv4len:
firstV4 = first // first is IPv4
case net.IPv6len:
// note, even if IP address length is 128 it still can be IPv4!
// need to do additional check converting it with `To4()`
firstV4 = first.To4()
if firstV4 == nil {
firstV6 = first // first is IPv6
}
default:
// invalid first IP address length
return nil, fmt.Errorf("%w: first", ErrInvalidIP)
}
// last IPv4 or IPv6
var lastV4, lastV6 net.IP
switch len(last) {
case net.IPv4len:
lastV4 = last // last is IPv4
case net.IPv6len:
// note, even if IP address length is 128 it still can be IPv4!
// need to do additional check converting it with `To4()`
lastV4 = last.To4()
if lastV4 == nil {
lastV6 = last // last is IPv6
}
default:
// invalid last IP address length
return nil, fmt.Errorf("%w: last", ErrInvalidIP)
}
switch {
case firstV4 != nil && lastV4 != nil:
return summarizeRange4(load32(firstV4), load32(lastV4)), nil
case firstV6 != nil && lastV6 != nil:
return summarizeRange6(load128(firstV6), load128(lastV6)), nil
}
return nil, ErrVersionMismatch
}
// summarizeRange4 returns a series of IPv4 networks which cover the range
// between the first and last IPv4 addresses, inclusive.
func summarizeRange4(first, last uint32) (networks []*net.IPNet) {
for first <= last {
// the network will either be as long as all the trailing zeros of the first address OR the number of bits
// necessary to cover the distance between first and last address -- whichever is smaller
nBits := 32
if z := bits.TrailingZeros32(first); z < nBits {
nBits = z
}
if first != 0 || last != maxUint32 { // guard overflow; this would just be 32 anyway
d := last - first + 1
if z := 31 - bits.LeadingZeros32(d); z < nBits {
nBits = z
}
}
nwkMask := net.CIDRMask(32-nBits, 32)
nwkIP := make(net.IP, net.IPv4len)
store32(first, nwkIP)
networks = append(networks,
&net.IPNet{
IP: nwkIP,
Mask: nwkMask,
})
first += 1 << nBits
if first == 0 {
break
}
}
return
}
// summarizeRange6 returns a series of IPv6 networks which cover the range
// between the first and last IPv6 addresses, inclusive.
func summarizeRange6(first, last Uint128) (networks []*net.IPNet) {
for first.Cmp(last) <= 0 { // first <= last
// the network will either be as long as all the trailing zeros of the first address OR the number of bits
// necessary to cover the distance between first and last address -- whichever is smaller
nBits := 128
if z := first.TrailingZeros(); z < nBits {
nBits = z
}
// check extremes to make sure no overflow
if !first.IsZero() || !last.Equals(u128.Max()) {
d := last.Sub(first).Add64(1)
if z := 127 - d.LeadingZeros(); z < nBits {
nBits = z
}
}
nwkMask := net.CIDRMask(128-nBits, 128)
nwkIP := make(net.IP, net.IPv6len)
store128(first, nwkIP)
networks = append(networks,
&net.IPNet{
IP: nwkIP,
Mask: nwkMask,
})
first = first.Add(Uint128{Lo: 1}.Lsh(uint(nBits)))
if first.IsZero() {
break
}
}
return
} | summarize.go | 0.826327 | 0.484624 | summarize.go | starcoder |
package openapi
import (
"encoding/json"
"fmt"
"net/url"
"strings"
"time"
"github.com/twilio/twilio-go/client"
)
// Optional parameters for the method 'CreateFax'
type CreateFaxParams struct {
// The number the fax was sent from. Can be the phone number in [E.164](https://www.twilio.com/docs/glossary/what-e164) format or the SIP `from` value. The caller ID displayed to the recipient uses this value. If this is a phone number, it must be a Twilio number or a verified outgoing caller id from your account. If `to` is a SIP address, this can be any alphanumeric string (and also the characters `+`, `_`, `.`, and `-`), which will be used in the `from` header of the SIP request.
From *string `json:"From,omitempty"`
// The URL of the PDF that contains the fax. See our [security](https://www.twilio.com/docs/usage/security) page for information on how to ensure the request for your media comes from Twilio.
MediaUrl *string `json:"MediaUrl,omitempty"`
// The [Fax Quality value](https://www.twilio.com/docs/fax/api/fax-resource#fax-quality-values) that describes the fax quality. Can be: `standard`, `fine`, or `superfine` and defaults to `fine`.
Quality *string `json:"Quality,omitempty"`
// The password to use with `sip_auth_username` to authenticate faxes sent to a SIP address.
SipAuthPassword *string `json:"SipAuthPassword,omitempty"`
// The username to use with the `sip_auth_password` to authenticate faxes sent to a SIP address.
SipAuthUsername *string `json:"SipAuthUsername,omitempty"`
// The URL we should call using the `POST` method to send [status information](https://www.twilio.com/docs/fax/api/fax-resource#fax-status-callback) to your application when the status of the fax changes.
StatusCallback *string `json:"StatusCallback,omitempty"`
// Whether to store a copy of the sent media on our servers for later retrieval. Can be: `true` or `false` and the default is `true`.
StoreMedia *bool `json:"StoreMedia,omitempty"`
// The phone number to receive the fax in [E.164](https://www.twilio.com/docs/glossary/what-e164) format or the recipient's SIP URI.
To *string `json:"To,omitempty"`
// How long in minutes from when the fax is initiated that we should try to send the fax.
Ttl *int `json:"Ttl,omitempty"`
}
func (params *CreateFaxParams) SetFrom(From string) *CreateFaxParams {
params.From = &From
return params
}
func (params *CreateFaxParams) SetMediaUrl(MediaUrl string) *CreateFaxParams {
params.MediaUrl = &MediaUrl
return params
}
func (params *CreateFaxParams) SetQuality(Quality string) *CreateFaxParams {
params.Quality = &Quality
return params
}
func (params *CreateFaxParams) SetSipAuthPassword(SipAuthPassword string) *CreateFaxParams {
params.SipAuthPassword = &SipAuthPassword
return params
}
func (params *CreateFaxParams) SetSipAuthUsername(SipAuthUsername string) *CreateFaxParams {
params.SipAuthUsername = &SipAuthUsername
return params
}
func (params *CreateFaxParams) SetStatusCallback(StatusCallback string) *CreateFaxParams {
params.StatusCallback = &StatusCallback
return params
}
func (params *CreateFaxParams) SetStoreMedia(StoreMedia bool) *CreateFaxParams {
params.StoreMedia = &StoreMedia
return params
}
func (params *CreateFaxParams) SetTo(To string) *CreateFaxParams {
params.To = &To
return params
}
func (params *CreateFaxParams) SetTtl(Ttl int) *CreateFaxParams {
params.Ttl = &Ttl
return params
}
// Create a new fax to send to a phone number or SIP endpoint.
func (c *ApiService) CreateFax(params *CreateFaxParams) (*FaxV1Fax, error) {
path := "/v1/Faxes"
data := url.Values{}
headers := make(map[string]interface{})
if params != nil && params.From != nil {
data.Set("From", *params.From)
}
if params != nil && params.MediaUrl != nil {
data.Set("MediaUrl", *params.MediaUrl)
}
if params != nil && params.Quality != nil {
data.Set("Quality", *params.Quality)
}
if params != nil && params.SipAuthPassword != nil {
data.Set("SipAuthPassword", *params.SipAuthPassword)
}
if params != nil && params.SipAuthUsername != nil {
data.Set("SipAuthUsername", *params.SipAuthUsername)
}
if params != nil && params.StatusCallback != nil {
data.Set("StatusCallback", *params.StatusCallback)
}
if params != nil && params.StoreMedia != nil {
data.Set("StoreMedia", fmt.Sprint(*params.StoreMedia))
}
if params != nil && params.To != nil {
data.Set("To", *params.To)
}
if params != nil && params.Ttl != nil {
data.Set("Ttl", fmt.Sprint(*params.Ttl))
}
resp, err := c.requestHandler.Post(c.baseURL+path, data, headers)
if err != nil {
return nil, err
}
defer resp.Body.Close()
ps := &FaxV1Fax{}
if err := json.NewDecoder(resp.Body).Decode(ps); err != nil {
return nil, err
}
return ps, err
}
// Delete a specific fax and its associated media.
func (c *ApiService) DeleteFax(Sid string) error {
path := "/v1/Faxes/{Sid}"
path = strings.Replace(path, "{"+"Sid"+"}", Sid, -1)
data := url.Values{}
headers := make(map[string]interface{})
resp, err := c.requestHandler.Delete(c.baseURL+path, data, headers)
if err != nil {
return err
}
defer resp.Body.Close()
return nil
}
// Fetch a specific fax.
func (c *ApiService) FetchFax(Sid string) (*FaxV1Fax, error) {
path := "/v1/Faxes/{Sid}"
path = strings.Replace(path, "{"+"Sid"+"}", Sid, -1)
data := url.Values{}
headers := make(map[string]interface{})
resp, err := c.requestHandler.Get(c.baseURL+path, data, headers)
if err != nil {
return nil, err
}
defer resp.Body.Close()
ps := &FaxV1Fax{}
if err := json.NewDecoder(resp.Body).Decode(ps); err != nil {
return nil, err
}
return ps, err
}
// Optional parameters for the method 'ListFax'
type ListFaxParams struct {
// Retrieve only those faxes sent from this phone number, specified in [E.164](https://www.twilio.com/docs/glossary/what-e164) format.
From *string `json:"From,omitempty"`
// Retrieve only those faxes sent to this phone number, specified in [E.164](https://www.twilio.com/docs/glossary/what-e164) format.
To *string `json:"To,omitempty"`
// Retrieve only those faxes with a `date_created` that is before or equal to this value, specified in [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) format.
DateCreatedOnOrBefore *time.Time `json:"DateCreatedOnOrBefore,omitempty"`
// Retrieve only those faxes with a `date_created` that is later than this value, specified in [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) format.
DateCreatedAfter *time.Time `json:"DateCreatedAfter,omitempty"`
// How many resources to return in each list page. The default is 50, and the maximum is 1000.
PageSize *int `json:"PageSize,omitempty"`
// Max number of records to return.
Limit *int `json:"limit,omitempty"`
}
func (params *ListFaxParams) SetFrom(From string) *ListFaxParams {
params.From = &From
return params
}
func (params *ListFaxParams) SetTo(To string) *ListFaxParams {
params.To = &To
return params
}
func (params *ListFaxParams) SetDateCreatedOnOrBefore(DateCreatedOnOrBefore time.Time) *ListFaxParams {
params.DateCreatedOnOrBefore = &DateCreatedOnOrBefore
return params
}
func (params *ListFaxParams) SetDateCreatedAfter(DateCreatedAfter time.Time) *ListFaxParams {
params.DateCreatedAfter = &DateCreatedAfter
return params
}
func (params *ListFaxParams) SetPageSize(PageSize int) *ListFaxParams {
params.PageSize = &PageSize
return params
}
func (params *ListFaxParams) SetLimit(Limit int) *ListFaxParams {
params.Limit = &Limit
return params
}
// Retrieve a single page of Fax records from the API. Request is executed immediately.
func (c *ApiService) PageFax(params *ListFaxParams, pageToken, pageNumber string) (*ListFaxResponse, error) {
path := "/v1/Faxes"
data := url.Values{}
headers := make(map[string]interface{})
if params != nil && params.From != nil {
data.Set("From", *params.From)
}
if params != nil && params.To != nil {
data.Set("To", *params.To)
}
if params != nil && params.DateCreatedOnOrBefore != nil {
data.Set("DateCreatedOnOrBefore", fmt.Sprint((*params.DateCreatedOnOrBefore).Format(time.RFC3339)))
}
if params != nil && params.DateCreatedAfter != nil {
data.Set("DateCreatedAfter", fmt.Sprint((*params.DateCreatedAfter).Format(time.RFC3339)))
}
if params != nil && params.PageSize != nil {
data.Set("PageSize", fmt.Sprint(*params.PageSize))
}
if pageToken != "" {
data.Set("PageToken", pageToken)
}
if pageNumber != "" {
data.Set("Page", pageNumber)
}
resp, err := c.requestHandler.Get(c.baseURL+path, data, headers)
if err != nil {
return nil, err
}
defer resp.Body.Close()
ps := &ListFaxResponse{}
if err := json.NewDecoder(resp.Body).Decode(ps); err != nil {
return nil, err
}
return ps, err
}
// Lists Fax records from the API as a list. Unlike stream, this operation is eager and loads 'limit' records into memory before returning.
func (c *ApiService) ListFax(params *ListFaxParams) ([]FaxV1Fax, error) {
if params == nil {
params = &ListFaxParams{}
}
params.SetPageSize(client.ReadLimits(params.PageSize, params.Limit))
response, err := c.PageFax(params, "", "")
if err != nil {
return nil, err
}
curRecord := 0
var records []FaxV1Fax
for response != nil {
records = append(records, response.Faxes...)
var record interface{}
if record, err = client.GetNext(c.baseURL, response, &curRecord, params.Limit, c.getNextListFaxResponse); record == nil || err != nil {
return records, err
}
response = record.(*ListFaxResponse)
}
return records, err
}
// Streams Fax records from the API as a channel stream. This operation lazily loads records as efficiently as possible until the limit is reached.
func (c *ApiService) StreamFax(params *ListFaxParams) (chan FaxV1Fax, error) {
if params == nil {
params = &ListFaxParams{}
}
params.SetPageSize(client.ReadLimits(params.PageSize, params.Limit))
response, err := c.PageFax(params, "", "")
if err != nil {
return nil, err
}
curRecord := 0
//set buffer size of the channel to 1
channel := make(chan FaxV1Fax, 1)
go func() {
for response != nil {
for item := range response.Faxes {
channel <- response.Faxes[item]
}
var record interface{}
if record, err = client.GetNext(c.baseURL, response, &curRecord, params.Limit, c.getNextListFaxResponse); record == nil || err != nil {
close(channel)
return
}
response = record.(*ListFaxResponse)
}
close(channel)
}()
return channel, err
}
func (c *ApiService) getNextListFaxResponse(nextPageUrl string) (interface{}, error) {
if nextPageUrl == "" {
return nil, nil
}
resp, err := c.requestHandler.Get(nextPageUrl, nil, nil)
if err != nil {
return nil, err
}
defer resp.Body.Close()
ps := &ListFaxResponse{}
if err := json.NewDecoder(resp.Body).Decode(ps); err != nil {
return nil, err
}
return ps, nil
}
// Optional parameters for the method 'UpdateFax'
type UpdateFaxParams struct {
// The new [status](https://www.twilio.com/docs/fax/api/fax-resource#fax-status-values) of the resource. Can be only `canceled`. This may fail if transmission has already started.
Status *string `json:"Status,omitempty"`
}
func (params *UpdateFaxParams) SetStatus(Status string) *UpdateFaxParams {
params.Status = &Status
return params
}
// Update a specific fax.
func (c *ApiService) UpdateFax(Sid string, params *UpdateFaxParams) (*FaxV1Fax, error) {
path := "/v1/Faxes/{Sid}"
path = strings.Replace(path, "{"+"Sid"+"}", Sid, -1)
data := url.Values{}
headers := make(map[string]interface{})
if params != nil && params.Status != nil {
data.Set("Status", *params.Status)
}
resp, err := c.requestHandler.Post(c.baseURL+path, data, headers)
if err != nil {
return nil, err
}
defer resp.Body.Close()
ps := &FaxV1Fax{}
if err := json.NewDecoder(resp.Body).Decode(ps); err != nil {
return nil, err
}
return ps, err
} | rest/fax/v1/faxes.go | 0.674908 | 0.424591 | faxes.go | starcoder |
package matrix
import (
"fmt"
"strings"
"algex/factor"
"algex/terms"
)
type Matrix struct {
// row count and col count
rows, cols int
// The matrix elements arranged, [r=0,c=0], [0,1], [0,2] ...
data []*terms.Exp
}
// NewMatrix creates a rows x cols matrix.
func NewMatrix(rows, cols int) (*Matrix, error) {
if rows <= 0 || cols <= 0 {
return nil, fmt.Errorf("need positive dimensions, not %dx%d", rows, cols)
}
m := &Matrix{
rows: rows,
cols: cols,
data: make([]*terms.Exp, rows*cols),
}
return m, nil
}
// String serializes a matrix for displaying.
func (m *Matrix) String() string {
var rs []string
for r := 0; r < m.rows; r++ {
var cs []string
for c := 0; c < m.cols; c++ {
cs = append(cs, m.data[c+m.cols*r].String())
}
rs = append(rs, "["+strings.Join(cs, ", ")+"]")
}
return "[" + strings.Join(rs, ", ") + "]"
}
// Set sets the value of a matrix element.
func (m *Matrix) Set(row, col int, e *terms.Exp) error {
if row < 0 || col < 0 || row >= m.rows || col >= m.cols {
return fmt.Errorf("bad cell: [%d,%d] in %dx%d matrix", row, col, m.rows, m.cols)
}
m.data[col+m.cols*row] = e
return nil
}
// El returns the row,col element of the matrix.
func (m *Matrix) El(row, col int) *terms.Exp {
return m.data[col+m.cols*row]
}
// Identity returns a square identity matrix of dimension n.
func Identity(n int) (*Matrix, error) {
if n <= 0 {
return nil, fmt.Errorf("invalid identity matrix of dimension n=%d", n)
}
m, _ := NewMatrix(n, n)
for i := 0; i < n; i++ {
m.Set(i, i, terms.NewExp([]factor.Value{factor.D(1, 1)}))
}
return m, nil
}
// Mul multiplies m x n with conventional matrix multiplication.
func (m *Matrix) Mul(n *Matrix) (*Matrix, error) {
if m.cols != n.rows {
return nil, fmt.Errorf("a cols(%d) != b rows(%d)", m.cols, n.rows)
}
a, err := NewMatrix(m.rows, n.cols)
if err != nil {
return nil, err
}
for r := 0; r < a.rows; r++ {
for c := 0; c < a.cols; c++ {
var e []*terms.Exp
for i := 0; i < m.cols; i++ {
x, y := m.El(r, i), n.El(i, c)
if x != nil && y != nil {
e = append(e, terms.Mul(x, y))
}
}
a.Set(r, c, terms.Add(e...))
}
}
return a, nil
}
// Mx multiplies two matrices and panics on error.
func (m *Matrix) Mx(n *Matrix) *Matrix {
a, err := m.Mul(n)
if err != nil {
panic(err)
}
return a
}
// Sum adds two matrices.
func (m *Matrix) Sum(n *Matrix, scale *terms.Exp) (*Matrix, error) {
if m.rows != n.rows || m.cols != n.cols {
return nil, fmt.Errorf("inequivalent dimensions %dx%d != %dx%d", m.rows, m.cols, n.rows, n.cols)
}
a, _ := NewMatrix(m.rows, m.cols)
for r := 0; r < m.rows; r++ {
for c := 0; c < m.cols; c++ {
if q := n.El(r, c); q == nil {
a.Set(r, c, m.El(r, c))
} else if p := m.El(r, c); p == nil {
a.Set(r, c, terms.Mul(q, scale))
} else {
a.Set(r, c, terms.Add(p, terms.Mul(q, scale)))
}
}
}
return a, nil
}
// Add adds two matrices, and panics on error.
func (m *Matrix) Add(n *Matrix, scale *terms.Exp) *Matrix {
a, err := m.Sum(n, scale)
if err != nil {
panic(err)
}
return a
}
// Performs a substitution on all elements of a matrix.
func (m *Matrix) Substitute(b []factor.Value, s *terms.Exp) *Matrix {
n, _ := NewMatrix(m.rows, m.cols)
for r := 0; r < m.rows; r++ {
for c := 0; c < m.cols; c++ {
n.Set(r, c, terms.Substitute(m.El(r, c), b, s))
}
}
return n
} | src/algex/matrix/matrix.go | 0.763131 | 0.557002 | matrix.go | starcoder |
package image
import (
"fmt"
"image"
"image/color"
"image/draw"
"image/png"
"os"
_ "golang.org/x/image/bmp"
_ "golang.org/x/image/tiff"
_ "golang.org/x/image/webp"
_ "image/jpeg"
_ "image/png"
)
// NewRGBA is a wrapper for image.RGBA which returns a new image of the desired size filled with color.
func NewRGBA(w, h int, col color.Color) *image.RGBA {
res := image.NewRGBA(image.Rect(0, 0, w, h))
bg := image.NewUniform(col)
draw.Draw(res, res.Bounds(), bg, image.Point{}, draw.Src)
return res
}
// NewRGBAVal is a wrapper for image.RGBA which returns a new image of the desired size filled with color.
func NewRGBAVal(w, h int, r, g, b, a uint8) *image.RGBA {
res := image.NewRGBA(image.Rect(0, 0, w, h))
bg := image.NewUniform(color.RGBA{r, g, b, a})
draw.Draw(res, res.Bounds(), bg, image.Point{}, draw.Src)
return res
}
// NewAlpha is a wrapper for image.Alpha which returns a new image of the desired size filled with color.
func NewAlpha(w, h int, col color.Color) *image.Alpha {
res := image.NewAlpha(image.Rect(0, 0, w, h))
bg := image.NewUniform(col)
draw.Draw(res, res.Bounds(), bg, image.Point{}, draw.Src)
return res
}
// NewAlphaVal is a wrapper for image.Alpha which returns a new image of the desired size filled with color.
func NewAlphaVal(w, h int, a uint8) *image.Alpha {
res := image.NewAlpha(image.Rect(0, 0, w, h))
bg := image.NewUniform(color.Alpha{a})
draw.Draw(res, res.Bounds(), bg, image.Point{}, draw.Src)
return res
}
// NewGray is a wrapper for image.Gray which returns a new image of the desired size filled with color.
func NewGray(w, h int, col color.Color) *image.Gray {
res := image.NewGray(image.Rect(0, 0, w, h))
bg := image.NewUniform(col)
draw.Draw(res, res.Bounds(), bg, image.Point{}, draw.Src)
return res
}
// NewGrayVal is a wrapper for image.Gray which returns a new image of the desired size filled with color.
func NewGrayVal(w, h int, g uint8) *image.Gray {
res := image.NewGray(image.Rect(0, 0, w, h))
bg := image.NewUniform(color.Gray{g})
draw.Draw(res, res.Bounds(), bg, image.Point{}, draw.Src)
return res
}
// NewGray16 is a wrapper for image.Gray16 which returns a new image of the desired size filled with color.
func NewGray16(w, h int, col color.Color) *image.Gray16 {
res := image.NewGray16(image.Rect(0, 0, w, h))
bg := image.NewUniform(col)
draw.Draw(res, res.Bounds(), bg, image.Point{}, draw.Src)
return res
}
// NewGray16Val is a wrapper for image.Gray which returns a new image of the desired size filled with color.
func NewGray16Val(w, h int, g uint16) *image.Gray16 {
res := image.NewGray16(image.Rect(0, 0, w, h))
bg := image.NewUniform(color.Gray16{g})
draw.Draw(res, res.Bounds(), bg, image.Point{}, draw.Src)
return res
}
// SaveImage is a utility function to save an image as a .png.
func SaveImage(img image.Image, name string) error {
fDst, err := os.Create(fmt.Sprintf("%s.png", name))
if err != nil {
return err
}
defer fDst.Close()
err = png.Encode(fDst, img)
if err != nil {
return err
}
return nil
}
// ReadImage is a utility function to read an image from a file.
func ReadImage(name string) (image.Image, error) {
f, err := os.Open(name)
if err != nil {
return nil, err
}
defer f.Close()
img, _, err := image.Decode(f)
if err != nil {
return nil, err
}
return img, nil
} | image/util.go | 0.813831 | 0.413004 | util.go | starcoder |
package main
import (
"fmt"
"os"
"unicode"
"github.com/syncd010/AoC2017/helpers"
)
// Validates the input
func validate(input []string) error {
// Accept
return nil
}
// Converts to an appropria format
func convert(input []string) []string {
return input
}
const UP, DOWN, LEFT, RIGHT = 'U', 'D', 'L', 'R'
type Position struct {
x, y int
dir byte
}
func (pos Position) move(dir byte) (newPos Position) {
newPos = pos
switch dir {
case DOWN:
newPos.y++
case UP:
newPos.y--
case RIGHT:
newPos.x++
case LEFT:
newPos.x--
}
return newPos
}
func findStartingPosition(input []string) (pos Position) {
pos.dir = DOWN
pos.y = 0
for i, c := range input[0] {
if c == '|' {
pos.x = i
return pos
}
}
return pos
}
func inBounds(pos Position, lenX, lenY int) bool {
if (pos.x >= 0) && (pos.x < lenX) &&
(pos.y >= 0) && (pos.y < lenY) {
return true
}
return false
}
func getCell(input []string, pos Position) (in bool, cell byte) {
lenX, lenY := len(input[0]), len(input)
if !inBounds(pos, lenX, lenY) {
return false, 0
}
return true, input[pos.y][pos.x]
}
func changeDirection(input []string, currPos Position) (pos Position) {
directions := map[byte][]byte{
UP: []byte{LEFT, RIGHT},
DOWN: []byte{LEFT, RIGHT},
LEFT: []byte{UP, DOWN},
RIGHT: []byte{UP, DOWN},
}
for _, dir := range directions[currPos.dir] {
newPos := currPos.move(dir)
if in, c := getCell(input, newPos); in && (c != ' ') {
currPos.dir = dir
return currPos
}
}
return currPos
}
func solve(input []string) (string, int) {
currPos := findStartingPosition(input)
var letters []byte
steps := 0
for in, c := getCell(input, currPos); in && (c != ' '); in, c = getCell(input, currPos) {
switch {
case c == '+':
currPos = changeDirection(input, currPos)
case unicode.IsLetter(rune(c)):
letters = append(letters, c)
}
currPos = currPos.move(currPos.dir)
steps++
}
return string(letters), steps
}
func solvePart1(input []string) string {
letters, _ := solve(input)
return letters
}
func solvePart2(input []string) int {
_, steps := solve(input)
return steps
}
func main() {
input := helpers.ReadInput(os.Args[1:]...)
helpers.Check(validate(input), "Please provide a valid input")
convertedInput := convert(input)
fmt.Printf("Fist part of the quiz is: %v\n", solvePart1(convertedInput))
fmt.Printf("Second part of the quiz is: %v\n", solvePart2(convertedInput))
} | day19/day19.go | 0.547948 | 0.405772 | day19.go | starcoder |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.