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 primitive
import (
"fmt"
"strings"
"math"
"github.com/fogleman/gg"
"github.com/golang/freetype/raster"
)
type Polygon struct {
Worker *Worker
Order int
Convex bool
MinAngle float64
SizeFactor float64
BoundsFactor int
X, Y []float64
}
// const m = 0
// const minAngle = 15
func NewRandomPolygon(worker *Worker, order int, convex bool, minAngle float64, sizeFactor float64, boundsFactor int) *Polygon {
w := worker.W
h := worker.H
rnd := worker.Rnd
x := make([]float64, order)
y := make([]float64, order)
x[0] = rnd.Float64() * float64(w)
y[0] = rnd.Float64() * float64(h)
for i := 1; i < order; i++ {
x[i] = clamp(x[0] + rnd.Float64()*sizeFactor - sizeFactor/2, float64(-boundsFactor), float64(w-1+boundsFactor))
y[i] = clamp(y[0] + rnd.Float64()*sizeFactor - sizeFactor/2, float64(-boundsFactor), float64(h-1+boundsFactor))
}
p := &Polygon{worker, order, convex, minAngle, sizeFactor, boundsFactor, x, y}
p.Mutate()
return p
}
func (p *Polygon) Draw(dc *gg.Context, scale float64) {
dc.NewSubPath()
for i := 0; i < p.Order; i++ {
dc.LineTo(p.X[i], p.Y[i])
}
dc.ClosePath()
dc.Fill()
}
func (p *Polygon) SVG(attrs string) string {
ret := fmt.Sprintf(
"<polygon %s points=\"",
attrs)
points := make([]string, len(p.X))
for i := 0; i < len(p.X); i++ {
points[i] = fmt.Sprintf("%f,%f", p.X[i], p.Y[i])
}
return ret + strings.Join(points, ",") + "\" />"
}
func (p *Polygon) Copy() Shape {
a := *p
a.X = make([]float64, p.Order)
a.Y = make([]float64, p.Order)
copy(a.X, p.X)
copy(a.Y, p.Y)
return &a
}
func (p *Polygon) Mutate() {
// vv("Polygon.Mutate")
w := p.Worker.W
h := p.Worker.H
boundsFactor := p.BoundsFactor
sizeFactor := p.SizeFactor
rnd := p.Worker.Rnd
for {
if rnd.Float64() < 0.25 {
i := rnd.Intn(p.Order)
j := rnd.Intn(p.Order)
p.X[i], p.Y[i], p.X[j], p.Y[j] = p.X[j], p.Y[j], p.X[i], p.Y[i]
} else {
i := rnd.Intn(p.Order)
p.X[i] = clamp(p.X[i]+rnd.NormFloat64()*sizeFactor/2, float64(-boundsFactor), float64(w-1+boundsFactor))
p.Y[i] = clamp(p.Y[i]+rnd.NormFloat64()*sizeFactor/2, float64(-boundsFactor), float64(h-1+boundsFactor))
}
if p.Valid() {
break
}
}
}
func (p *Polygon) Valid() bool {
if !p.Convex {
return true
}
var sign bool
for a := 0; a < p.Order; a++ {
i := (a + 0) % p.Order
j := (a + 1) % p.Order
k := (a + 2) % p.Order
c := cross3(p.X[i], p.Y[i], p.X[j], p.Y[j], p.X[k], p.Y[k])
if a == 0 {
sign = c > 0
} else if c > 0 != sign {
return false
}
}
// check internal angles of polygon.
for a := 0; a < p.Order; a++ {
i := (a + 0) % p.Order
j := (a + 1) % p.Order
k := (a + 2) % p.Order
a := angleBetween(p.X[i], p.Y[i], p.X[j], p.Y[j], p.X[k], p.Y[k])
if a < p.MinAngle {
return false
}
}
w, h := float64(p.Worker.W), float64(p.Worker.H)
boundsFactor := float64(p.BoundsFactor)
for idx := 0; idx < p.Order; idx++ {
if p.X[idx] < -boundsFactor || p.X[idx] > w + boundsFactor {
return false
}
if p.Y[idx] < -boundsFactor || p.Y[idx] > h + boundsFactor {
return false
}
}
return true
}
func cross3(x1, y1, x2, y2, x3, y3 float64) float64 {
dx1 := x2 - x1
dy1 := y2 - y1
dx2 := x3 - x2
dy2 := y3 - y2
return dx1*dy2 - dy1*dx2
}
func (p *Polygon) Rasterize() []Scanline {
var path raster.Path
for i := 0; i <= p.Order; i++ {
f := fixp(p.X[i%p.Order], p.Y[i%p.Order])
if i == 0 {
path.Start(f)
} else {
path.Add1(f)
}
}
return fillPath(p.Worker, path)
}
func (p *Polygon) Area() float64 {
x := p.X
y := p.Y
x = append(x, x[0])
y = append(y, y[0])
order := len(x)
// var area float64 = p.X[order - 1]*p.X[0] - p.X[0]*p.Y[order - 1]
var area float64 = 0.0
for idx := 0; idx < order - 1; idx++ {
area += x[idx]*y[idx + 1] - x[idx + 1]*y[idx]
}
area = math.Abs(area)/2.0
return area
}
func mag (x, y float64) float64 {
return math.Sqrt(math.Pow(x, 2) + math.Pow(y, 2))
}
func dot (x0, y0, x1, y1 float64) float64 {
return x0*x1 + y0*y1
}
// Get the angle created by vector between (x1, y1) -> (x0, y0) and (x1, y1) -> (x2, y2). Returns angle in degrees
func angleBetween (x0, y0, x1, y1, x2, y2 float64) float64 {
x0 -= x1
y0 -= y1
x2 -= x1
y2 -= y1
mag0 := mag(x0, y0)
mag2 := mag(x2, y2)
dot02 := dot(x0, y0, x2, y2)
angle := degrees(math.Acos(dot02 / (mag0 * mag2)))
return angle
} | primitive/polygon.go | 0.662141 | 0.47725 | polygon.go | starcoder |
package jin
import "strconv"
// Get returns the value that path has pointed.
// It stripes quotation marks from string values.
// Path can point anything, a key-value pair, a value, an array, an object.
// Path variable can not be null,
// otherwise it will provide an error message.
func (p *Parser) Get(path ...string) ([]byte, error) {
if len(path) == 0 {
return p.json, nil
}
curr, err := p.core.walk(path)
if err != nil {
return nil, err
}
return cleanValue(curr.value), nil
}
// GetNew returns the value that path has pointed.
// It stripes quotation marks from string values.
// Path can point anything, a key-value pair, a value, an array, an object.
// Path variable can not be null,
// otherwise it will provide an error message.
func (p *Parser) GetNew(path ...string) []byte {
var err error
curr := p.core
if len(path) != 0 {
curr, err = p.core.walk(path)
if err != nil {
return nil
}
}
if len(curr.down) == 0 {
return cleanValue(curr.value)
}
temp := make([]byte, 0, 128)
temp = curr.dive(temp)
return cleanValue(temp)
}
// GetString is a variation of Get() func.
// GetString returns the value that path has pointed as string.
func (p *Parser) GetString(path ...string) (string, error) {
val, err := p.Get(path...)
if err != nil {
return "", err
}
return string(val), err
}
// GetInt is a variation of Get() func.
// GetInt returns the value that path has pointed as integer.
// returns an error message if the value to be returned cannot be converted to an integer
func (p *Parser) GetInt(path ...string) (int, error) {
val, err := p.GetString(path...)
if err != nil {
return -1, err
}
intVal, err := strconv.Atoi(val)
if err != nil {
return -1, intParseError(val)
}
return intVal, nil
}
// GetFloat is a variation of Get() func.
// GetFloat returns the value that path has pointed as float.
// returns an error message if the value to be returned cannot be converted to an float
func (p *Parser) GetFloat(path ...string) (float64, error) {
val, err := p.GetString(path...)
if err != nil {
return -1, err
}
floatVal, err := strconv.ParseFloat(val, 64)
if err != nil {
return -1, floatParseError(val)
}
return floatVal, nil
}
// GetBool is a variation of Get() func.
// GetBool returns the value that path has pointed as boolean.
// returns an error message if the value to be returned cannot be converted to an boolean
func (p *Parser) GetBool(path ...string) (bool, error) {
val, err := p.GetString(path...)
if err != nil {
return false, err
}
if val == "true" {
return true, nil
}
if val == "false" {
return false, nil
}
return false, boolParseError(val)
}
// GetStringArray is a variation of Get() func.
// GetStringArray returns the value that path has pointed as string slice.
// returns an error message if the value to be returned cannot be converted to an string slice.
func (p *Parser) GetStringArray(path ...string) ([]string, error) {
val, err := p.GetString(path...)
if err != nil {
return nil, err
}
lena := len(val)
if lena < 2 {
return nil, stringArrayParseError(val)
}
if val[0] == 91 && val[lena-1] == 93 {
arr := ParseArray(val)
if arr == nil {
return nil, stringArrayParseError(val)
}
return arr, nil
}
return nil, stringArrayParseError(val)
}
// GetIntArray is a variation of Get() func.
// GetIntArray returns the value that path has pointed as integer slice.
// returns an error message if the value to be returned cannot be converted to an integer slice.
func (p *Parser) GetIntArray(path ...string) ([]int, error) {
val, err := p.GetString(path...)
if err != nil {
return nil, err
}
lena := len(val)
if lena < 2 {
return nil, intArrayParseError(val)
}
if val[0] == 91 && val[lena-1] == 93 {
newArray := make([]int, 0, 16)
start := 1
inQuote := false
level := 0
for i := 0; i < len(val); i++ {
curr := val[i]
if curr == 92 {
i++
continue
}
if curr == 34 {
inQuote = !inQuote
continue
}
if inQuote {
continue
} else {
if curr == 91 || curr == 123 {
level++
}
if curr == 93 || curr == 125 {
level--
if curr == 93 {
if level == 0 {
element := val[start:i]
num, err := strconv.Atoi(cleanValueString(element))
if err != nil {
return nil, intParseError(cleanValueString(element))
}
newArray = append(newArray, num)
break
}
}
}
if level == 1 {
if curr == 44 {
element := val[start:i]
num, err := strconv.Atoi(cleanValueString(element))
if err != nil {
return nil, intParseError(cleanValueString(element))
}
newArray = append(newArray, num)
start = i + 1
continue
}
}
}
}
return newArray, nil
}
return nil, intArrayParseError(val)
}
// GetFloatArray is a variation of Get() func.
// GetFloatArray returns the value that path has pointed as float slice.
// returns an error message if the value to be returned cannot be converted to an float slice.
func (p *Parser) GetFloatArray(path ...string) ([]float64, error) {
val, err := p.GetString(path...)
if err != nil {
return nil, err
}
lena := len(val)
if lena < 2 {
return nil, floatArrayParseError(val)
}
if val[0] == 91 && val[lena-1] == 93 {
newArray := make([]float64, 0, 16)
start := 1
inQuote := false
level := 0
for i := 0; i < len(val); i++ {
curr := val[i]
if curr == 92 {
i++
continue
}
if curr == 34 {
inQuote = !inQuote
continue
}
if inQuote {
continue
} else {
if curr == 91 || curr == 123 {
level++
}
if curr == 93 || curr == 125 {
level--
if curr == 93 {
if level == 0 {
element := val[start:i]
num, err := strconv.ParseFloat(cleanValueString(element), 64)
if err != nil {
return nil, floatParseError(cleanValueString(element))
}
newArray = append(newArray, num)
break
}
}
}
if level == 1 {
if curr == 44 {
element := val[start:i]
num, err := strconv.ParseFloat(cleanValueString(element), 64)
if err != nil {
return nil, floatParseError(cleanValueString(element))
}
newArray = append(newArray, num)
start = i + 1
continue
}
}
}
}
return newArray, nil
}
return nil, floatArrayParseError(val)
}
// GetBoolArray is a variation of Get() func.
// GetBoolArray returns the value that path has pointed as boolean slice.
// returns an error message if the value to be returned cannot be converted to an boolean slice.
func (p *Parser) GetBoolArray(path ...string) ([]bool, error) {
val, err := p.GetString(path...)
if err != nil {
return nil, err
}
lena := len(val)
if lena < 2 {
return nil, boolArrayParseError(val)
}
if val[0] == 91 && val[lena-1] == 93 {
newArray := make([]bool, 0, 16)
start := 1
inQuote := false
level := 0
for i := 0; i < len(val); i++ {
curr := val[i]
if curr == 92 {
i++
continue
}
if curr == 34 {
inQuote = !inQuote
continue
}
if inQuote {
continue
} else {
if curr == 91 || curr == 123 {
level++
}
if curr == 93 || curr == 125 {
level--
if curr == 93 {
if level == 0 {
element := val[start:i]
element = cleanValueString(element)
if element == "true" || element == "false" {
if element == "true" {
newArray = append(newArray, true)
} else {
newArray = append(newArray, false)
}
} else {
return nil, boolParseError(cleanValueString(element))
}
break
}
}
}
if level == 1 {
if curr == 44 {
element := val[start:i]
element = cleanValueString(element)
if element == "true" || element == "false" {
if element == "true" {
newArray = append(newArray, true)
} else {
newArray = append(newArray, false)
}
} else {
return nil, boolParseError(element)
}
start = i + 1
continue
}
}
}
}
return newArray, nil
}
return nil, boolArrayParseError(val)
} | parse_get.go | 0.667798 | 0.42931 | parse_get.go | starcoder |
package operators
import (
onnx "github.com/owulveryck/onnx-go"
"gorgonia.org/gorgonia"
)
// Div operator
// https://github.com/onnx/onnx/blob/master/docs/Operators.md#Div
type Div struct {
name string
}
// Init of the operator; the operator does not expect any attribute; therefore, any value of attrs is silently discarded
func (o *Div) Init(attrs []*onnx.AttributeProto) error {
o.name = "Div"
return nil
}
// Apply the Hadamard Div to the input nodes. Broadcasting is computed and applied if needed
func (o *Div) Apply(input ...*gorgonia.Node) ([]*gorgonia.Node, error) {
if len(input) != 2 {
return nil, &ErrBadArity{
Operator: o.name,
ExpectedInput: 2,
ActualInput: len(input),
}
}
var bcastPattern gorgonia.BroadcastPattern
x := input[0]
y := input[1]
switch {
case len(x.Shape()) == 1 && len(y.Shape()) != 1:
// Need left broadcasting
// Make an educated guess: find the axis that has the same dimension
// as x.Shape()[0] and broadcast on all axes of y but this one.
var leftPattern []byte
dims := make([]int, len(x.Shape()))
for i := 0; i < len(y.Shape()); i++ {
if y.Shape()[i] != x.Shape()[0] {
dims[i] = 1
leftPattern = append(leftPattern, byte(i))
} else {
dims[i] = x.Shape()[0]
}
}
var err error
x, err = gorgonia.Reshape(input[0], dims)
if err != nil {
return nil, err
}
bcastPattern = gorgonia.NewBroadcastPattern(leftPattern, nil)
case len(y.Shape()) == 1 && len(x.Shape()) != 1:
// Need right broadcasting
var rightPattern []byte
dims := make([]int, len(x.Shape()))
for i := 0; i < len(x.Shape()); i++ {
if x.Shape()[i] != y.Shape()[0] {
dims[i] = 1
rightPattern = append(rightPattern, byte(i))
} else {
dims[i] = y.Shape()[0]
}
}
var err error
y, err = gorgonia.Reshape(input[1], dims)
if err != nil {
return nil, err
}
bcastPattern = gorgonia.NewBroadcastPattern(nil, rightPattern)
case len(y.Shape()) == 3 && len(x.Shape()) == 4:
// Ugly hack for the mnist model
dims := make([]int, 4)
dims[0] = 1
for i := 0; i < 3; i++ {
dims[i+1] = input[1].Shape()[i]
}
var err error
y, err = gorgonia.Reshape(input[1], dims)
if err != nil {
return nil, err
}
bcastPattern = gorgonia.NewBroadcastPattern(nil, []byte{0, 2, 3})
case len(y.Shape()) == 4 && len(x.Shape()) == 3:
// Ugly hack for the mnist model
dims := make([]int, 4)
dims[0] = 1
for i := 0; i < 3; i++ {
dims[i+1] = input[0].Shape()[i]
}
var err error
x, err = gorgonia.Reshape(input[0], dims)
if err != nil {
return nil, err
}
bcastPattern = gorgonia.NewBroadcastPattern([]byte{0, 2, 3}, nil)
}
n, err := gorgonia.HadamardDiv(x, y, bcastPattern)
return []*gorgonia.Node{n}, err
} | operators/div.go | 0.751192 | 0.446253 | div.go | starcoder |
package api
func init() {
Swagger.Add("iam_v2beta_policy", `{
"swagger": "2.0",
"info": {
"title": "components/automate-gateway/api/iam/v2beta/policy.proto",
"version": "version not set"
},
"schemes": [
"http",
"https"
],
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"paths": {
"/iam/v2beta/policies": {
"get": {
"operationId": "ListPolicies",
"responses": {
"200": {
"description": "A successful response.",
"schema": {
"$ref": "#/definitions/v2betaListPoliciesResp"
}
}
},
"tags": [
"Policies"
]
},
"post": {
"operationId": "CreatePolicy",
"responses": {
"200": {
"description": "A successful response.",
"schema": {
"$ref": "#/definitions/v2betaCreatePolicyResp"
}
}
},
"parameters": [
{
"name": "body",
"in": "body",
"required": true,
"schema": {
"$ref": "#/definitions/v2betaCreatePolicyReq"
}
}
],
"tags": [
"Policies"
]
}
},
"/iam/v2beta/policies/{id}": {
"get": {
"operationId": "GetPolicy",
"responses": {
"200": {
"description": "A successful response.",
"schema": {
"$ref": "#/definitions/v2betaGetPolicyResp"
}
}
},
"parameters": [
{
"name": "id",
"in": "path",
"required": true,
"type": "string"
}
],
"tags": [
"Policies"
]
},
"delete": {
"operationId": "DeletePolicy",
"responses": {
"200": {
"description": "A successful response.",
"schema": {
"$ref": "#/definitions/v2betaDeletePolicyResp"
}
}
},
"parameters": [
{
"name": "id",
"in": "path",
"required": true,
"type": "string"
}
],
"tags": [
"Policies"
]
},
"put": {
"operationId": "UpdatePolicy",
"responses": {
"200": {
"description": "A successful response.",
"schema": {
"$ref": "#/definitions/v2betaUpdatePolicyResp"
}
}
},
"parameters": [
{
"name": "id",
"in": "path",
"required": true,
"type": "string"
},
{
"name": "body",
"in": "body",
"required": true,
"schema": {
"$ref": "#/definitions/v2betaUpdatePolicyReq"
}
}
],
"tags": [
"Policies"
]
}
},
"/iam/v2beta/policies/{id}/members": {
"get": {
"operationId": "ListPolicyMembers",
"responses": {
"200": {
"description": "A successful response.",
"schema": {
"$ref": "#/definitions/v2betaListPolicyMembersResp"
}
}
},
"parameters": [
{
"name": "id",
"in": "path",
"required": true,
"type": "string"
}
],
"tags": [
"Policies"
]
},
"put": {
"operationId": "ReplacePolicyMembers",
"responses": {
"200": {
"description": "A successful response.",
"schema": {
"$ref": "#/definitions/v2betaReplacePolicyMembersResp"
}
}
},
"parameters": [
{
"name": "id",
"in": "path",
"required": true,
"type": "string"
},
{
"name": "body",
"in": "body",
"required": true,
"schema": {
"$ref": "#/definitions/v2betaReplacePolicyMembersReq"
}
}
],
"tags": [
"Policies"
]
}
},
"/iam/v2beta/policies/{id}/members:add": {
"post": {
"operationId": "AddPolicyMembers",
"responses": {
"200": {
"description": "A successful response.",
"schema": {
"$ref": "#/definitions/v2betaAddPolicyMembersResp"
}
}
},
"parameters": [
{
"name": "id",
"in": "path",
"required": true,
"type": "string"
},
{
"name": "body",
"in": "body",
"required": true,
"schema": {
"$ref": "#/definitions/v2betaAddPolicyMembersReq"
}
}
],
"tags": [
"Policies"
]
}
},
"/iam/v2beta/policies/{id}/members:remove": {
"post": {
"operationId": "RemovePolicyMembers",
"responses": {
"200": {
"description": "A successful response.",
"schema": {
"$ref": "#/definitions/v2betaRemovePolicyMembersResp"
}
}
},
"parameters": [
{
"name": "id",
"in": "path",
"required": true,
"type": "string"
},
{
"name": "body",
"in": "body",
"required": true,
"schema": {
"$ref": "#/definitions/v2betaRemovePolicyMembersReq"
}
}
],
"tags": [
"Policies"
]
}
},
"/iam/v2beta/policy_version": {
"get": {
"operationId": "GetPolicyVersion",
"responses": {
"200": {
"description": "A successful response.",
"schema": {
"$ref": "#/definitions/v2betaGetPolicyVersionResp"
}
}
},
"tags": [
"Policies"
]
}
},
"/iam/v2beta/projects": {
"get": {
"operationId": "ListProjects",
"responses": {
"200": {
"description": "A successful response.",
"schema": {
"$ref": "#/definitions/v2betaListProjectsResp"
}
}
},
"tags": [
"Policies"
]
},
"post": {
"operationId": "CreateProject",
"responses": {
"200": {
"description": "A successful response.",
"schema": {
"$ref": "#/definitions/v2betaCreateProjectResp"
}
}
},
"parameters": [
{
"name": "body",
"in": "body",
"required": true,
"schema": {
"$ref": "#/definitions/v2betaCreateProjectReq"
}
}
],
"tags": [
"Policies"
]
}
},
"/iam/v2beta/projects/{id}": {
"get": {
"operationId": "GetProject",
"responses": {
"200": {
"description": "A successful response.",
"schema": {
"$ref": "#/definitions/v2betaGetProjectResp"
}
}
},
"parameters": [
{
"name": "id",
"in": "path",
"required": true,
"type": "string"
}
],
"tags": [
"Policies"
]
},
"delete": {
"operationId": "DeleteProject",
"responses": {
"200": {
"description": "A successful response.",
"schema": {
"$ref": "#/definitions/v2betaDeleteProjectResp"
}
}
},
"parameters": [
{
"name": "id",
"in": "path",
"required": true,
"type": "string"
}
],
"tags": [
"Policies"
]
},
"put": {
"operationId": "UpdateProject",
"responses": {
"200": {
"description": "A successful response.",
"schema": {
"$ref": "#/definitions/v2betaUpdateProjectResp"
}
}
},
"parameters": [
{
"name": "id",
"in": "path",
"required": true,
"type": "string"
},
{
"name": "body",
"in": "body",
"required": true,
"schema": {
"$ref": "#/definitions/v2betaUpdateProjectReq"
}
}
],
"tags": [
"Policies"
]
}
},
"/iam/v2beta/roles": {
"get": {
"operationId": "ListRoles",
"responses": {
"200": {
"description": "A successful response.",
"schema": {
"$ref": "#/definitions/v2betaListRolesResp"
}
}
},
"tags": [
"Policies"
]
},
"post": {
"operationId": "CreateRole",
"responses": {
"200": {
"description": "A successful response.",
"schema": {
"$ref": "#/definitions/v2betaCreateRoleResp"
}
}
},
"parameters": [
{
"name": "body",
"in": "body",
"required": true,
"schema": {
"$ref": "#/definitions/v2betaCreateRoleReq"
}
}
],
"tags": [
"Policies"
]
}
},
"/iam/v2beta/roles/{id}": {
"get": {
"operationId": "GetRole",
"responses": {
"200": {
"description": "A successful response.",
"schema": {
"$ref": "#/definitions/v2betaGetRoleResp"
}
}
},
"parameters": [
{
"name": "id",
"in": "path",
"required": true,
"type": "string"
}
],
"tags": [
"Policies"
]
},
"delete": {
"operationId": "DeleteRole",
"responses": {
"200": {
"description": "A successful response.",
"schema": {
"$ref": "#/definitions/v2betaDeleteRoleResp"
}
}
},
"parameters": [
{
"name": "id",
"in": "path",
"required": true,
"type": "string"
}
],
"tags": [
"Policies"
]
},
"put": {
"operationId": "UpdateRole",
"responses": {
"200": {
"description": "A successful response.",
"schema": {
"$ref": "#/definitions/v2betaUpdateRoleResp"
}
}
},
"parameters": [
{
"name": "id",
"in": "path",
"required": true,
"type": "string"
},
{
"name": "body",
"in": "body",
"required": true,
"schema": {
"$ref": "#/definitions/v2betaUpdateRoleReq"
}
}
],
"tags": [
"Policies"
]
}
}
},
"definitions": {
"StatementEffect": {
"type": "string",
"enum": [
"ALLOW",
"DENY"
],
"default": "ALLOW"
},
"VersionVersionNumber": {
"type": "string",
"enum": [
"V0",
"V1",
"V2"
],
"default": "V0"
},
"iamv2betaType": {
"type": "string",
"enum": [
"CHEF_MANAGED",
"CUSTOM"
],
"default": "CHEF_MANAGED"
},
"v2betaAddPolicyMembersReq": {
"type": "object",
"properties": {
"id": {
"type": "string"
},
"members": {
"type": "array",
"items": {
"type": "string"
}
}
}
},
"v2betaAddPolicyMembersResp": {
"type": "object",
"properties": {
"members": {
"type": "array",
"items": {
"type": "string"
}
}
}
},
"v2betaCreatePolicyReq": {
"type": "object",
"properties": {
"id": {
"type": "string"
},
"name": {
"type": "string"
},
"members": {
"type": "array",
"items": {
"type": "string"
}
},
"statements": {
"type": "array",
"items": {
"$ref": "#/definitions/v2betaStatement"
}
},
"projects": {
"type": "array",
"items": {
"type": "string"
}
}
},
"description": "Does not contain type as the enduser can only create 'custom' policies."
},
"v2betaCreatePolicyResp": {
"type": "object",
"properties": {
"policy": {
"$ref": "#/definitions/v2betaPolicy"
}
}
},
"v2betaCreateProjectReq": {
"type": "object",
"properties": {
"id": {
"type": "string"
},
"name": {
"type": "string"
}
}
},
"v2betaCreateProjectResp": {
"type": "object",
"properties": {
"project": {
"$ref": "#/definitions/v2betaProject"
}
}
},
"v2betaCreateRoleReq": {
"type": "object",
"properties": {
"id": {
"type": "string"
},
"name": {
"type": "string"
},
"actions": {
"type": "array",
"items": {
"type": "string"
}
},
"projects": {
"type": "array",
"items": {
"type": "string"
}
}
},
"description": "Does not contain type as the enduser can only create 'custom' roles."
},
"v2betaCreateRoleResp": {
"type": "object",
"properties": {
"role": {
"$ref": "#/definitions/v2betaRole"
}
}
},
"v2betaDeletePolicyResp": {
"type": "object"
},
"v2betaDeleteProjectResp": {
"type": "object"
},
"v2betaDeleteRoleResp": {
"type": "object"
},
"v2betaFlag": {
"type": "string",
"enum": [
"VERSION_2_0",
"VERSION_2_1"
],
"default": "VERSION_2_0",
"title": "passed to UpgradeToV2 to set version"
},
"v2betaGetPolicyResp": {
"type": "object",
"properties": {
"policy": {
"$ref": "#/definitions/v2betaPolicy"
}
}
},
"v2betaGetPolicyVersionResp": {
"type": "object",
"properties": {
"version": {
"$ref": "#/definitions/v2betaVersion"
}
}
},
"v2betaGetProjectResp": {
"type": "object",
"properties": {
"project": {
"$ref": "#/definitions/v2betaProject"
}
}
},
"v2betaGetRoleResp": {
"type": "object",
"properties": {
"role": {
"$ref": "#/definitions/v2betaRole"
}
}
},
"v2betaListPoliciesResp": {
"type": "object",
"properties": {
"policies": {
"type": "array",
"items": {
"$ref": "#/definitions/v2betaPolicy"
}
}
}
},
"v2betaListPolicyMembersResp": {
"type": "object",
"properties": {
"members": {
"type": "array",
"items": {
"type": "string"
}
}
}
},
"v2betaListProjectsResp": {
"type": "object",
"properties": {
"projects": {
"type": "array",
"items": {
"$ref": "#/definitions/v2betaProject"
}
}
}
},
"v2betaListRolesResp": {
"type": "object",
"properties": {
"roles": {
"type": "array",
"items": {
"$ref": "#/definitions/v2betaRole"
}
}
}
},
"v2betaPolicy": {
"type": "object",
"properties": {
"name": {
"type": "string"
},
"id": {
"type": "string"
},
"type": {
"$ref": "#/definitions/iamv2betaType"
},
"members": {
"type": "array",
"items": {
"type": "string"
}
},
"statements": {
"type": "array",
"items": {
"$ref": "#/definitions/v2betaStatement"
}
},
"projects": {
"type": "array",
"items": {
"type": "string"
}
}
}
},
"v2betaProject": {
"type": "object",
"properties": {
"name": {
"type": "string"
},
"id": {
"type": "string"
},
"type": {
"$ref": "#/definitions/iamv2betaType"
},
"projects": {
"type": "array",
"items": {
"type": "string"
}
}
}
},
"v2betaRemovePolicyMembersReq": {
"type": "object",
"properties": {
"id": {
"type": "string"
},
"members": {
"type": "array",
"items": {
"type": "string"
}
}
}
},
"v2betaRemovePolicyMembersResp": {
"type": "object",
"properties": {
"members": {
"type": "array",
"items": {
"type": "string"
}
}
}
},
"v2betaReplacePolicyMembersReq": {
"type": "object",
"properties": {
"id": {
"type": "string"
},
"members": {
"type": "array",
"items": {
"type": "string"
}
}
}
},
"v2betaReplacePolicyMembersResp": {
"type": "object",
"properties": {
"members": {
"type": "array",
"items": {
"type": "string"
}
}
}
},
"v2betaResetToV1Resp": {
"type": "object"
},
"v2betaRole": {
"type": "object",
"properties": {
"name": {
"type": "string"
},
"id": {
"type": "string"
},
"type": {
"$ref": "#/definitions/iamv2betaType"
},
"actions": {
"type": "array",
"items": {
"type": "string"
}
},
"projects": {
"type": "array",
"items": {
"type": "string"
}
}
}
},
"v2betaStatement": {
"type": "object",
"properties": {
"effect": {
"$ref": "#/definitions/StatementEffect"
},
"actions": {
"type": "array",
"items": {
"type": "string"
},
"title": "inline definitions"
},
"role": {
"type": "string",
"title": "references"
},
"resources": {
"type": "array",
"items": {
"type": "string"
},
"title": "Note: these are for display only, not to be set in CreatePolicy/UpdatePolicy"
}
}
},
"v2betaUpdatePolicyReq": {
"type": "object",
"properties": {
"id": {
"type": "string"
},
"members": {
"type": "array",
"items": {
"type": "string"
}
},
"statements": {
"type": "array",
"items": {
"$ref": "#/definitions/v2betaStatement"
}
},
"name": {
"type": "string"
},
"projects": {
"type": "array",
"items": {
"type": "string"
}
}
},
"description": "Does not contain type as the enduser can only create 'custom' policies."
},
"v2betaUpdatePolicyResp": {
"type": "object",
"properties": {
"policy": {
"$ref": "#/definitions/v2betaPolicy"
}
}
},
"v2betaUpdateProjectReq": {
"type": "object",
"properties": {
"id": {
"type": "string"
},
"name": {
"type": "string"
}
}
},
"v2betaUpdateProjectResp": {
"type": "object",
"properties": {
"project": {
"$ref": "#/definitions/v2betaProject"
}
}
},
"v2betaUpdateRoleReq": {
"type": "object",
"properties": {
"id": {
"type": "string"
},
"name": {
"type": "string"
},
"actions": {
"type": "array",
"items": {
"type": "string"
}
},
"projects": {
"type": "array",
"items": {
"type": "string"
}
}
}
},
"v2betaUpdateRoleResp": {
"type": "object",
"properties": {
"role": {
"$ref": "#/definitions/v2betaRole"
}
}
},
"v2betaUpgradeToV2Resp": {
"type": "object",
"properties": {
"reports": {
"type": "array",
"items": {
"type": "string"
}
}
}
},
"v2betaVersion": {
"type": "object",
"properties": {
"major": {
"$ref": "#/definitions/VersionVersionNumber"
},
"minor": {
"$ref": "#/definitions/VersionVersionNumber"
}
},
"title": "the only values that may be returned by GetPolicyVersion"
}
}
}
`)
} | components/automate-gateway/api/iam_v2beta_policy.pb.swagger.go | 0.627152 | 0.406214 | iam_v2beta_policy.pb.swagger.go | starcoder |
package boxlayout
import "math"
type Dimensions struct {
X0 int
X1 int
Y0 int
Y1 int
}
type Direction int
const (
ROW Direction = iota
COLUMN
)
// to give a high-level explanation of what's going on here. We layout our windows by arranging a bunch of boxes in the available space.
// If a box has children, it needs to specify how it wants to arrange those children: ROW or COLUMN.
// If a box represents a window, you can put the window name in the Window field.
// When determining how to divvy-up the available height (for row children) or width (for column children), we first
// give the boxes with a static `size` the space that they want. Then we apportion
// the remaining space based on the weights of the dynamic boxes (you can't define
// both size and weight at the same time: you gotta pick one). If there are two
// boxes, one with weight 1 and the other with weight 2, the first one gets 33%
// of the available space and the second one gets the remaining 66%
type Box struct {
// Direction decides how the children boxes are laid out. ROW means the children will each form a row i.e. that they will be stacked on top of eachother.
Direction Direction
// function which takes the width and height assigned to the box and decides which orientation it will have
ConditionalDirection func(width int, height int) Direction
Children []*Box
// function which takes the width and height assigned to the box and decides the layout of the children.
ConditionalChildren func(width int, height int) []*Box
// Window refers to the name of the window this box represents, if there is one
Window string
// static Size. If parent box's direction is ROW this refers to height, otherwise width
Size int
// dynamic size. Once all statically sized children have been considered, Weight decides how much of the remaining space will be taken up by the box
// TODO: consider making there be one int and a type enum so we can't have size and Weight simultaneously defined
Weight int
}
func ArrangeWindows(root *Box, x0, y0, width, height int) map[string]Dimensions {
children := root.getChildren(width, height)
if len(children) == 0 {
// leaf node
if root.Window != "" {
dimensionsForWindow := Dimensions{X0: x0, Y0: y0, X1: x0 + width - 1, Y1: y0 + height - 1}
return map[string]Dimensions{root.Window: dimensionsForWindow}
}
return map[string]Dimensions{}
}
direction := root.getDirection(width, height)
var availableSize int
if direction == COLUMN {
availableSize = width
} else {
availableSize = height
}
// work out size taken up by children
reservedSize := 0
totalWeight := 0
for _, child := range children {
// assuming either size or weight are non-zero
reservedSize += child.Size
totalWeight += child.Weight
}
remainingSize := availableSize - reservedSize
if remainingSize < 0 {
remainingSize = 0
}
unitSize := 0
extraSize := 0
if totalWeight > 0 {
unitSize = remainingSize / totalWeight
extraSize = remainingSize % totalWeight
}
result := map[string]Dimensions{}
offset := 0
for _, child := range children {
var boxSize int
if child.isStatic() {
boxSize = child.Size
} else {
// TODO: consider more evenly distributing the remainder
boxSize = unitSize * child.Weight
boxExtraSize := int(math.Min(float64(extraSize), float64(child.Weight)))
boxSize += boxExtraSize
extraSize -= boxExtraSize
}
var resultForChild map[string]Dimensions
if direction == COLUMN {
resultForChild = ArrangeWindows(child, x0+offset, y0, boxSize, height)
} else {
resultForChild = ArrangeWindows(child, x0, y0+offset, width, boxSize)
}
result = mergeDimensionMaps(result, resultForChild)
offset += boxSize
}
return result
}
func (b *Box) isStatic() bool {
return b.Size > 0
}
func (b *Box) getDirection(width int, height int) Direction {
if b.ConditionalDirection != nil {
return b.ConditionalDirection(width, height)
}
return b.Direction
}
func (b *Box) getChildren(width int, height int) []*Box {
if b.ConditionalChildren != nil {
return b.ConditionalChildren(width, height)
}
return b.Children
}
func mergeDimensionMaps(a map[string]Dimensions, b map[string]Dimensions) map[string]Dimensions {
result := map[string]Dimensions{}
for _, dimensionMap := range []map[string]Dimensions{a, b} {
for k, v := range dimensionMap {
result[k] = v
}
}
return result
} | pkg/gui/boxlayout/boxlayout.go | 0.52074 | 0.606702 | boxlayout.go | starcoder |
package serialization
import (
"fmt"
"math"
"math/big"
"math/bits"
)
const (
maxMagLength = math.MaxInt32/32 + 1
longMask = int64(0xffffffff)
)
// BigInt is a port of java.math.BigInteger with only the necessary bits.
type BigInt struct {
mag []int32
signum int32
}
// NewBigInt creates a BigInt from the given big.Int
func NewBigInt(b *big.Int) BigInt {
mag := wordsToInt32(b.Bits())
return BigInt{signum: int32(b.Sign()), mag: mag}
}
// GoBigInt returns a big.Int from this BigInt
func (b BigInt) GoBigInt() *big.Int {
bb := new(big.Int)
if len(b.mag) == 0 {
return bb
}
bb.SetBits(int32ArrToWords(b.mag))
if b.signum < 0 {
bb.Neg(bb)
}
return bb
}
// NewBigIntFromByteArray creates a BigInt from the given byte array.
func NewBigIntFromByteArray(val []byte) (BigInt, error) {
var mag []int32
var signum int32
if len(val) == 0 {
return BigInt{}, fmt.Errorf("zero length BigInt")
}
if val[0] >= 128 {
mag = makePositive(val)
signum = -1
} else {
mag = stripLeadingZeroBytes(val)
signum = 0
if len(mag) > 0 {
signum = 1
}
}
if len(mag) > maxMagLength || len(mag) == maxMagLength && mag[0] < 0 {
return BigInt{}, fmt.Errorf("big int overflow")
}
return BigInt{signum: signum, mag: mag}, nil
}
// Bytes returns a java.math.BigInteger compatible byte array
func (b BigInt) Bytes() []byte {
byteLen := b.bitLength()/8 + 1
byteArr := make([]byte, byteLen)
copied := 4
nextInt := int32(0)
intIndex := 0
for i := byteLen - 1; i >= 0; i-- {
if copied == 4 {
nextInt = b.getInt(intIndex)
intIndex++
copied = 1
} else {
nextInt >>= 8
copied++
}
byteArr[i] = byte(nextInt)
}
return byteArr
}
func (b BigInt) bitLength() int {
m := b.mag
l := len(m)
if l == 0 {
return 0
}
magBitLen := ((l - 1) << 5) + bits.Len32(uint32(m[0]))
if b.signum >= 0 {
return magBitLen
}
pow2 := bits.OnesCount32(uint32(m[0])) == 1
for i := 1; i < l && pow2; i++ {
pow2 = m[i] == 0
}
n := magBitLen
if pow2 {
n--
}
return n
}
func (b BigInt) getInt(n int) int32 {
if n < 0 {
return 0
}
if n >= len(b.mag) {
if b.signum < 0 {
return -1
}
return 0
}
magInt := b.mag[len(b.mag)-n-1]
if b.signum >= 0 {
return magInt
}
if n <= b.firstNonZeroIntNum() {
return -magInt
}
return ^magInt
}
func (b BigInt) firstNonZeroIntNum() int {
// Search for the first nonzero int
var i int
mlen := len(b.mag)
for i = mlen - 1; i >= 0 && b.mag[i] == 0; i-- {
}
return mlen - i - 1
}
func makePositive(a []byte) []int32 {
var keep, k int32
byteLen := int32(len(a))
// Find first non-sign (0xff) byte of input
keep = 0
for ; keep < byteLen && a[keep] == 0xff; keep++ {
}
// Allocate output array.
// If all non-sign bytes are 0x00, we must allocate space for one extra output byte.
k = keep
for ; k < byteLen && a[k] == 0; k++ {
}
extraByte := int32(0)
if k == byteLen {
extraByte = 1
}
intLen := ((byteLen - keep + extraByte) + 3) >> 2
result := make([]int32, intLen)
// Copy one's complement of input into output, leaving extra byte (if it exists) == 0x00
b := byteLen - 1
for i := intLen - 1; i >= 0; i-- {
result[i] = int32(a[b]) & 0xff
b--
numBytesToTransfer := b - keep + 1
if 3 < numBytesToTransfer {
numBytesToTransfer = 3
}
if numBytesToTransfer < 0 {
numBytesToTransfer = 0
}
for j := 8; int32(j) <= 8*numBytesToTransfer; j += 8 {
result[i] |= (int32(a[b]) & 0xff) << j
b--
}
// Mask indicates which bits must be complemented
mask := uint32(longMask) >> (8 * (3 - numBytesToTransfer))
result[i] = ^result[i] & int32(mask)
}
// Add one to one's complement to generate two's complement
for i := len(result) - 1; i >= 0; i-- {
result[i] = int32((int64(result[i]) & longMask) + 1)
if result[i] != 0 {
break
}
}
return result
}
func stripLeadingZeroBytes(a []byte) []int32 {
byteLen := int32(len(a))
keep := int32(0)
// Find first nonzero byte
for ; keep < byteLen && a[keep] == 0; keep++ {
}
// Allocate new array and copy relevant part of input array
intLen := ((byteLen - keep) + 3) >> 2
result := make([]int32, intLen)
b := byteLen - 1
for i := intLen - 1; i >= 0; i-- {
result[i] = int32(a[b]) & 0xff
b--
bytesRemaining := b - keep + 1
bytesToTransfer := bytesRemaining
if 3 < bytesToTransfer {
bytesToTransfer = 3
}
for j := int32(8); j <= bytesToTransfer<<3; j += 8 {
result[i] |= (int32(a[b]) & 0xff) << j
b--
}
}
return result
}
// wordsToInt32 converts the given big.Int bits to java.math.BigInteger magnitude
func wordsToInt32(ws []big.Word) []int32 {
if bits.UintSize == 32 {
return wordsToInt32Arr32(ws)
}
return wordsToInt32Arr64(ws)
}
func wordsToInt32Arr32(ws []big.Word) []int32 {
bs := make([]int32, len(ws))
l := len(bs)
for i := l - 1; i >= 0; i-- {
bs[l-i-1] = int32(ws[i])
}
return bs
}
func wordsToInt32Arr64(ws []big.Word) []int32 {
bs := make([]int32, len(ws)*2)
l := len(bs)
x := 0
for i := len(ws) - 1; i >= 0; i-- {
w := ws[i]
bs[x+1] = int32(w)
bs[x] = int32(w >> 32)
x += 2
}
// remove leading zeros
i := 0
for ; i < l && bs[i] == 0; i++ {
}
if i != 0 {
bs = bs[i:]
}
return bs
}
// int32ArrToWords converts the given java.math.BigInteger magnitude to big.Int bits.
func int32ArrToWords(a []int32) []big.Word {
if bits.UintSize == 32 {
return int32ArrToWords32(a)
}
return int32ArrToWords64(a)
}
func int32ArrToWords32(a []int32) []big.Word {
l := len(a)
ws := make([]big.Word, l)
for i, b := range a {
ws[l-1-i] = big.Word(b)
}
return ws
}
func int32ArrToWords64(a []int32) []big.Word {
l := len(a)
ws := make([]big.Word, l/2+l%2)
if l%2 == 1 {
// prepend the extra 0 to make the length even
a2 := make([]int32, l+1)
for i, x := range a {
a2[i+1] = x
}
a = a2
l = len(a)
}
x := l - 1
for i := 0; i < len(ws); i++ {
ws[i] = big.Word((int64(a[x-1]) << 32) | (int64(a[x]) & 0xffffffff))
x -= 2
}
return ws
} | internal/serialization/big_int.go | 0.70304 | 0.471467 | big_int.go | starcoder |
package geom
import (
"reflect"
"github.com/ctessum/polyclip-go"
)
// A Path is a series of connected points.
type Path []Point
// Len returns the number of Points in the receiver.
func (p Path) Len() int {
return len(p)
}
// XY returns the coordinates of point i.
func (p Path) XY(i int) (x, y float64) {
return p[i].X, p[i].Y
}
// A Polygon is a series of closed rings. The inner rings should be nested
// inside of the outer ring.
type Polygon []Path
// Bounds gives the rectangular extents of the polygon.
func (p Polygon) Bounds() *Bounds {
b := NewBounds()
b.extendPointss(p)
return b
}
// Polygons returns []{p} to fulfill the Polygonal interface.
func (p Polygon) Polygons() []Polygon {
return []Polygon{p}
}
// Intersection returns the area(s) shared by p and p2.
func (p Polygon) Intersection(p2 Polygonal) Polygonal {
return p.op(p2, polyclip.INTERSECTION)
}
// Union returns the combination of p and p2.
func (p Polygon) Union(p2 Polygonal) Polygonal {
return p.op(p2, polyclip.UNION)
}
// XOr returns the area(s) occupied by either p or p2 but not both.
func (p Polygon) XOr(p2 Polygonal) Polygonal {
return p.op(p2, polyclip.XOR)
}
// Difference subtracts p2 from p.
func (p Polygon) Difference(p2 Polygonal) Polygonal {
return p.op(p2, polyclip.DIFFERENCE)
}
func (p Polygon) op(p2 Polygonal, op polyclip.Op) Polygon {
pp := p.toPolyClip()
var pp2 polyclip.Polygon
for _, pp2x := range p2.Polygons() {
pp2 = append(pp2, pp2x.toPolyClip()...)
}
return polyClipToPolygon(pp.Construct(op, pp2))
}
func (p Polygon) toPolyClip() polyclip.Polygon {
o := make(polyclip.Polygon, len(p))
for i, r := range p {
o[i] = make(polyclip.Contour, len(r))
for j, pp := range r {
o[i][j] = polyclip.Point(pp)
}
}
return o
}
func polyClipToPolygon(p polyclip.Polygon) Polygon {
pp := make(Polygon, len(p))
for i, r := range p {
pp[i] = make([]Point, len(r)+1)
for j, ppp := range r {
pp[i][j] = Point(ppp)
}
// Close the ring as per OGC standard.
pp[i][len(r)] = pp[i][0]
}
return pp
}
// Len returns the number of points in the receiver.
func (p Polygon) Len() int {
var i int
for _, r := range p {
i += len(r)
}
return i
}
// Points returns an iterator for the points in the receiver.
func (p Polygon) Points() func() Point {
var i, j int
return func() Point {
if i == len(p[j]) {
j++
i = 0
}
i++
return p[j][i-1]
}
}
// Within calculates whether p is within poly.
func (p Polygon) Within(poly Polygonal) WithinStatus {
if reflect.DeepEqual(p, poly) {
return OnEdge
}
for _, r := range p {
for _, pt := range r {
if pointInPolygonal(pt, poly) == Outside {
return Outside
}
}
}
return Inside
} | polygon.go | 0.821546 | 0.717903 | polygon.go | starcoder |
package urlutil
import (
"net/http"
"reflect"
"strconv"
)
// Values maps a string key to a list of values.
// It is typically used for query parameters and form values.
// Unlike in the http.Header map, the keys in a Values map
// are case-sensitive.
type Values map[string][]string
// Query returns query string values from a http request.
func Query(r *http.Request) Values {
v := Values{}
if r == nil || r.URL == nil {
return v
}
for key, value := range r.URL.Query() {
v[key] = value
}
return v
}
// Bool gets the first value associated with the given key.
// If there are no values associated with the key, Bool returns
// false. To access multiple values, use the map directly.
func (v Values) Bool(key string, def ...interface{}) bool {
s := v.Get(key)
d := value(false, def...).(bool)
if len(s) == 0 {
return d
}
b, err := strconv.ParseBool(s)
if err != nil {
return d
}
return b
}
// Float gets the first value associated with the given key.
// If there are no values associated with the key, Float returns
// zero. To access multiple values, use the map directly.
func (v Values) Float(key string, def ...interface{}) float64 {
s := v.Get(key)
d := value(float64(0.0), def...).(float64)
if len(s) == 0 {
return d
}
f, err := strconv.ParseFloat(s, 64)
if err != nil {
return d
}
return f
}
// Int gets the first value associated with the given key.
// If there are no values associated with the key, Int returns
// zero. To access multiple values, use the map directly.
func (v Values) Int(key string, def ...interface{}) int {
s := v.Get(key)
d := value(0, def...).(int)
if len(s) == 0 {
return d
}
i, err := strconv.Atoi(s)
if err != nil {
return d
}
return i
}
// Get gets the first value associated with the given key.
// If there are no values associated with the key, Get returns
// the empty string. To access multiple values, use the map
// directly.
func (v Values) Get(key string, def ...interface{}) string {
d := value("", def...).(string)
if v == nil {
return d
}
vs := v[key]
if len(vs) == 0 {
return d
}
if v := vs[0]; len(v) > 0 {
return v
}
return d
}
// Set sets the key to value. It replaces any existing
// values.
func (v Values) Set(key, value string) {
v[key] = []string{value}
}
// Add adds the value to key. It appends to any existing
// values associated with key.
func (v Values) Add(key, value string) {
v[key] = append(v[key], value)
}
// Del deletes the values associated with key.
func (v Values) Del(key string) {
delete(v, key)
}
func value(def interface{}, values ...interface{}) interface{} {
if len(values) == 0 {
return def
}
v := values[0]
if reflect.TypeOf(def).Kind() == reflect.TypeOf(v).Kind() {
return v
}
return def
} | urlutil/urlutil.go | 0.765243 | 0.496155 | urlutil.go | starcoder |
package agents
import (
"time"
"math"
"github.com/hajimehoshi/ebiten/v2"
"github.com/jtbonhomme/asteboids/internal/physics"
"github.com/jtbonhomme/asteboids/internal/sounds"
"github.com/jtbonhomme/asteboids/internal/vector"
"github.com/sirupsen/logrus"
)
const (
bulletThrottle time.Duration = 200 * time.Millisecond
rotationAngle float64 = math.Pi / 36 // rotation of 5°
starshipMaxVelocity float64 = 3.0
starshipAcceleration float64 = 0.2
)
// Starship is a PhysicalBody agent.
// It represents a playable star ship.
type Starship struct {
physics.Body
lastBulletTime time.Time
bulletImage *ebiten.Image
}
// NewStarship creates a new Starship (PhysicalBody agent)
func NewStarship(
log *logrus.Logger,
x, y,
screenWidth, screenHeight float64,
cbr physics.AgentRegister,
cbu physics.AgentUnregister,
vision physics.AgentVision,
starshipImage *ebiten.Image,
bulletImage *ebiten.Image,
debug bool) *Starship {
s := Starship{
lastBulletTime: time.Now(),
}
s.AgentType = physics.StarshipAgent
s.Register = cbr
s.Unregister = cbu
s.Vision = vision
s.Init(vector.Vector2D{
X: 0,
Y: 0,
})
s.LimitVelocity(starshipMaxVelocity)
s.Orientation = math.Pi / 2
s.Move(vector.Vector2D{
X: x,
Y: y,
})
s.Accelerate(vector.Vector2D{
X: 0,
Y: 0,
})
s.PhysicWidth = 50
s.PhysicHeight = 50
s.ScreenWidth = screenWidth
s.ScreenHeight = screenHeight
s.Log = log
s.Image = starshipImage
s.bulletImage = bulletImage
s.Debug = debug
return &s
}
// Update proceeds the game state.
// Update is called every tick (1/60 [s] by default).
func (s *Starship) Update() {
if ebiten.IsKeyPressed(ebiten.KeyLeft) {
s.Rotate(-rotationAngle)
} else if ebiten.IsKeyPressed(ebiten.KeyRight) {
s.Rotate(rotationAngle)
}
if ebiten.IsKeyPressed(ebiten.KeyUp) {
acceleration := vector.Vector2D{
X: math.Cos(s.Orientation),
Y: math.Sin(s.Orientation),
}
acceleration.Multiply(starshipAcceleration)
s.Accelerate(acceleration)
go func() {
_ = sounds.ThrustPlayer.Rewind()
sounds.ThrustPlayer.Play()
}()
} else {
s.Accelerate(vector.Vector2D{})
}
if ebiten.IsKeyPressed(ebiten.KeyEscape) {
s.SelfDestroy()
}
if ebiten.IsKeyPressed(ebiten.KeySpace) {
s.Shot()
go func() {
_ = sounds.FirePlayer.Rewind()
sounds.FirePlayer.Play()
}()
}
s.UpdateVelocity()
s.UpdatePosition()
}
// Shot adds a new bullet to the game.
func (s *Starship) Shot() {
// throtlle call to avoid continuous shooting
if time.Since(s.lastBulletTime) < bulletThrottle {
return
}
s.lastBulletTime = time.Now()
bullet := NewBullet(s.Log,
s.Position().X, s.Position().Y,
s.Orientation,
s.ScreenWidth,
s.ScreenHeight,
s.Unregister,
s.bulletImage)
s.Register(bullet)
}
// Draw draws the game screen.
// Draw is called every frame (typically 1/60[s] for 60Hz display).
func (s *Starship) Draw(screen *ebiten.Image) {
defer s.Body.Draw(screen)
nearestAgent := s.Vision(s.Position().X, s.Position().Y)
s.LinkAgents(screen, nearestAgent, []string{physics.AsteroidAgent, physics.RubbleAgent})
}
// SelfDestroy removes the agent from the game
func (s *Starship) SelfDestroy() {
go func() {
_ = sounds.BangLargePlayer.Rewind()
sounds.BangLargePlayer.Play()
}()
s.Unregister(s.ID(), s.Type())
}
// Explode proceeds the rubble termination.
func (s *Starship) Explode() {
s.Unregister(s.ID(), s.Type())
go func() {
_ = sounds.BangLargePlayer.Rewind()
sounds.BangLargePlayer.Play()
}()
} | internal/agents/starship.go | 0.625781 | 0.42173 | starship.go | starcoder |
package datum
import (
"fmt"
"math"
"sort"
"sync/atomic"
"time"
)
// Datum is an interface for metric datums, with a type, value and timestamp to be exported.
type Datum interface {
// // Type returns the Datum type.
// Type() metrics.Type
// ValueString returns the value of a Datum as a string.
ValueString() string
// TimeString returns the timestamp of a Datum as a string.
TimeString() string
// Time returns the timestamp of the Datum as time.Time in UTC
TimeUTC() time.Time
}
// BaseDatum is a struct used to record timestamps across all Datum implementations.
type BaseDatum struct {
Time int64 // nanoseconds since unix epoch
}
var zeroTime time.Time
func (d *BaseDatum) stamp(timestamp time.Time) {
if timestamp.IsZero() {
atomic.StoreInt64(&d.Time, time.Now().UTC().UnixNano())
} else {
atomic.StoreInt64(&d.Time, timestamp.UnixNano())
}
}
// TimeString returns the timestamp of this Datum as a string.
func (d *BaseDatum) TimeString() string {
return fmt.Sprintf("%d", atomic.LoadInt64(&d.Time)/1e9)
}
func (d *BaseDatum) TimeUTC() time.Time {
tNsec := atomic.LoadInt64(&d.Time)
return time.Unix(tNsec/1e9, tNsec%1e9)
}
// NewInt creates a new zero integer datum.
func NewInt() Datum {
return MakeInt(0, zeroTime)
}
// NewFloat creates a new zero floating-point datum.
func NewFloat() Datum {
return MakeFloat(0., zeroTime)
}
// NewString creates a new zero string datum.
func NewString() Datum {
return MakeString("", zeroTime)
}
// NewBuckets creates a new zero buckets datum.
func NewBuckets(buckets []Range) Datum {
return MakeBuckets(buckets, zeroTime)
}
// MakeInt creates a new integer datum with the provided value and timestamp.
func MakeInt(v int64, ts time.Time) Datum {
d := &Int{}
d.Set(v, ts)
return d
}
// MakeFloat creates a new floating-point datum with the provided value and timestamp.
func MakeFloat(v float64, ts time.Time) Datum {
d := &Float{}
d.Set(v, ts)
return d
}
// MakeString creates a new string datum with the provided value and timestamp.
func MakeString(v string, ts time.Time) Datum {
d := &String{}
d.Set(v, ts)
return d
}
// MakeBuckets creates a new bucket datum with the provided list of ranges and
// timestamp. If no +inf bucket is provided, one is created.
func MakeBuckets(buckets []Range, ts time.Time) Datum {
d := &Buckets{}
seenInf := false
highest := 0.0
for _, b := range buckets {
d.AddBucket(b)
if math.IsInf(b.Max, +1) {
seenInf = true
} else if b.Max > highest {
highest = b.Max
}
}
if !seenInf {
d.AddBucket(Range{highest, math.Inf(+1)})
}
return d
}
// GetInt returns the integer value of a datum, or error.
func GetInt(d Datum) int64 {
switch d := d.(type) {
case *Int:
return d.Get()
default:
panic(fmt.Sprintf("datum %v is not an Int", d))
}
}
// GetFloat returns the floating-point value of a datum, or error.
func GetFloat(d Datum) float64 {
switch d := d.(type) {
case *Float:
return d.Get()
default:
panic(fmt.Sprintf("datum %v is not a Float", d))
}
}
// GetString returns the string of a datum, or error.
func GetString(d Datum) string {
switch d := d.(type) {
case *String:
return d.Get()
default:
panic(fmt.Sprintf("datum %v is not a String", d))
}
}
// SetInt sets an integer datum to the provided value and timestamp, or panics if the Datum is not an IntDatum.
func SetInt(d Datum, v int64, ts time.Time) {
switch d := d.(type) {
case *Int:
d.Set(v, ts)
case *Buckets:
d.Observe(float64(v), ts)
default:
panic(fmt.Sprintf("datum %v is not an Int", d))
}
}
// SetFloat sets a floating-point Datum to the provided value and timestamp, or panics if the Datum is not a FloatDatum.
func SetFloat(d Datum, v float64, ts time.Time) {
switch d := d.(type) {
case *Float:
d.Set(v, ts)
case *Buckets:
d.Observe(v, ts)
default:
panic(fmt.Sprintf("datum %v is not a Float", d))
}
}
// SetString sets a string Datum to the provided value and timestamp, or panics if the Datym is not a String Datum.
func SetString(d Datum, v string, ts time.Time) {
switch d := d.(type) {
case *String:
d.Set(v, ts)
default:
panic(fmt.Sprintf("datum %v is not a String", d))
}
}
// IncIntBy increments an integer Datum by the provided value, at time ts, or panics if the Datum is not an IntDatum.
func IncIntBy(d Datum, v int64, ts time.Time) {
switch d := d.(type) {
case *Int:
d.IncBy(v, ts)
default:
panic(fmt.Sprintf("datum %v is not an Int", d))
}
}
// DecIntBy increments an integer Datum by the provided value, at time ts, or panics if the Datum is not an IntDatum.
func DecIntBy(d Datum, v int64, ts time.Time) {
switch d := d.(type) {
case *Int:
d.DecBy(v, ts)
default:
panic(fmt.Sprintf("datum %v is not an Int", d))
}
}
func GetBuckets(d Datum) *Buckets {
switch d := d.(type) {
case *Buckets:
return d
default:
panic(fmt.Sprintf("datum %v is not a Buckets", d))
}
}
// Observe records an observation v at time ts in d, or panics if d is not a BucketsDatum.
func Observe(d Datum, v float64, ts time.Time) {
switch d := d.(type) {
case *Buckets:
d.Observe(v, ts)
default:
panic(fmt.Sprintf("datum %v is not a Buckets", d))
}
}
// GetBucketCount returns the total count of observations in d, or panics if d is not a BucketsDatum.
func GetBucketsCount(d Datum) uint64 {
switch d := d.(type) {
case *Buckets:
return d.GetCount()
default:
panic(fmt.Sprintf("datum %v is not a Buckets", d))
}
}
// GetBucketsSum returns the sum of observations in d, or panics if d is not a BucketsDatum.
func GetBucketsSum(d Datum) float64 {
switch d := d.(type) {
case *Buckets:
return d.GetSum()
default:
panic(fmt.Sprintf("datum %v is not a Buckets", d))
}
}
// GetBucketsCumByMax returns a map of cumulative bucket observations by their
// upper bonds, or panics if d is not a BucketsDatum.
func GetBucketsCumByMax(d Datum) map[float64]uint64 {
switch d := d.(type) {
case *Buckets:
buckets := make(map[float64]uint64)
maxes := make([]float64, 0)
for r, c := range d.GetBuckets() {
maxes = append(maxes, r.Max)
buckets[r.Max] = c
}
sort.Float64s(maxes)
cum := uint64(0)
for _, m := range maxes {
cum += buckets[m]
buckets[m] = cum
}
return buckets
default:
panic(fmt.Sprintf("datum %v is not a Buckets", d))
}
} | internal/metrics/datum/datum.go | 0.800068 | 0.593668 | datum.go | starcoder |
package basic
import (
"math"
"github.com/starainrt/astro/planet"
. "github.com/starainrt/astro/tools"
)
func SaturnL(JD float64) float64 {
return planet.WherePlanet(5, 0, JD)
}
func SaturnB(JD float64) float64 {
return planet.WherePlanet(5, 1, JD)
}
func SaturnR(JD float64) float64 {
return planet.WherePlanet(5, 2, JD)
}
func ASaturnX(JD float64) float64 {
l := SaturnL(JD)
b := SaturnB(JD)
r := SaturnR(JD)
el := planet.WherePlanet(-1, 0, JD)
eb := planet.WherePlanet(-1, 1, JD)
er := planet.WherePlanet(-1, 2, JD)
x := r*Cos(b)*Cos(l) - er*Cos(eb)*Cos(el)
return x
}
func ASaturnY(JD float64) float64 {
l := SaturnL(JD)
b := SaturnB(JD)
r := SaturnR(JD)
el := planet.WherePlanet(-1, 0, JD)
eb := planet.WherePlanet(-1, 1, JD)
er := planet.WherePlanet(-1, 2, JD)
y := r*Cos(b)*Sin(l) - er*Cos(eb)*Sin(el)
return y
}
func ASaturnZ(JD float64) float64 {
//l := SaturnL(JD)
b := SaturnB(JD)
r := SaturnR(JD)
// el := planet.WherePlanet(-1, 0, JD)
eb := planet.WherePlanet(-1, 1, JD)
er := planet.WherePlanet(-1, 2, JD)
z := r*Sin(b) - er*Sin(eb)
return z
}
func ASaturnXYZ(JD float64) (float64, float64, float64) {
l := SaturnL(JD)
b := SaturnB(JD)
r := SaturnR(JD)
el := planet.WherePlanet(-1, 0, JD)
eb := planet.WherePlanet(-1, 1, JD)
er := planet.WherePlanet(-1, 2, JD)
x := r*Cos(b)*Cos(l) - er*Cos(eb)*Cos(el)
y := r*Cos(b)*Sin(l) - er*Cos(eb)*Sin(el)
z := r*Sin(b) - er*Sin(eb)
return x, y, z
}
func SaturnSeeRa(JD float64) float64 {
lo, bo := SaturnSeeLoBo(JD)
sita := Sita(JD)
ra := math.Atan2((Sin(lo)*Cos(sita) - Tan(bo)*Sin(sita)), Cos(lo))
ra = ra * 180 / math.Pi
return Limit360(ra)
}
func SaturnSeeDec(JD float64) float64 {
lo, bo := SaturnSeeLoBo(JD)
sita := Sita(JD)
dec := ArcSin(Sin(bo)*Cos(sita) + Cos(bo)*Sin(sita)*Sin(lo))
return dec
}
func SaturnSeeRaDec(JD float64) (float64, float64) {
lo, bo := SaturnSeeLoBo(JD)
sita := Sita(JD)
ra := math.Atan2((Sin(lo)*Cos(sita) - Tan(bo)*Sin(sita)), Cos(lo))
ra = ra * 180 / math.Pi
dec := ArcSin(Sin(bo)*Cos(sita) + Cos(bo)*Sin(sita)*Sin(lo))
return Limit360(ra), dec
}
func EarthSaturnAway(JD float64) float64 {
x, y, z := ASaturnXYZ(JD)
to := math.Sqrt(x*x + y*y + z*z)
return to
}
func SaturnSeeLo(JD float64) float64 {
x, y, z := ASaturnXYZ(JD)
to := 0.0057755183 * math.Sqrt(x*x+y*y+z*z)
x, y, z = ASaturnXYZ(JD - to)
lo := math.Atan2(y, x)
bo := math.Atan2(z, math.Sqrt(x*x+y*y))
lo = lo * 180 / math.Pi
bo = bo * 180 / math.Pi
lo = Limit360(lo)
//lo-=GXCLo(lo,bo,JD)/3600;
//bo+=GXCBo(lo,bo,JD);
lo += HJZD(JD)
return lo
}
func SaturnSeeBo(JD float64) float64 {
x, y, z := ASaturnXYZ(JD)
to := 0.0057755183 * math.Sqrt(x*x+y*y+z*z)
x, y, z = ASaturnXYZ(JD - to)
//lo := math.Atan2(y, x)
bo := math.Atan2(z, math.Sqrt(x*x+y*y))
//lo = lo * 180 / math.Pi
bo = bo * 180 / math.Pi
//lo+=GXCLo(lo,bo,JD);
//bo+=GXCBo(lo,bo,JD)/3600;
//lo+=HJZD(JD);
return bo
}
func SaturnSeeLoBo(JD float64) (float64, float64) {
x, y, z := ASaturnXYZ(JD)
to := 0.0057755183 * math.Sqrt(x*x+y*y+z*z)
x, y, z = ASaturnXYZ(JD - to)
lo := math.Atan2(y, x)
bo := math.Atan2(z, math.Sqrt(x*x+y*y))
lo = lo * 180 / math.Pi
bo = bo * 180 / math.Pi
lo = Limit360(lo)
//lo-=GXCLo(lo,bo,JD)/3600;
//bo+=GXCBo(lo,bo,JD);
lo += HJZD(JD)
return lo, bo
}
func SaturnMag(JD float64) float64 {
AwaySun := SaturnR(JD)
AwayEarth := EarthSaturnAway(JD)
Away := planet.WherePlanet(-1, 2, JD)
i := (AwaySun*AwaySun + AwayEarth*AwayEarth - Away*Away) / (2 * AwaySun * AwayEarth)
i = ArcCos(i)
Mag := -8.68 + 5*math.Log10(AwaySun*AwayEarth) + 0.044*i - 2.6*Sin(math.Abs(SaturnRingB(JD))) + 1.25*Sin(math.Abs(SaturnRingB(JD)))*Sin(math.Abs(SaturnRingB(JD)))
return FloatRound(Mag, 2)
}
func SaturnRingB(JD float64) float64 {
T := (JD - 2451545) / 36525
i := 28.075216 - 0.012998*T + 0.000004*T*T
omi := 169.508470 + 1.394681*T + 0.000412*T*T
lo, bo := SaturnSeeLoBo(JD)
B := Sin(i)*Cos(bo)*Sin(lo-omi) - Cos(i)*Cos(bo)
return ArcSin(B)
} | basic/saturn.go | 0.692538 | 0.471649 | saturn.go | starcoder |
package bn256
import (
"math/big"
"errors"
)
// twistPoint implements the elliptic curve Y²=X³+3/ξ over GF(p²). Points are
// kept in Jacobian form and T=Z² when valid. The group G₂ is the set of
// n-torsion points of this curve over GF(p²) (where n = Order)
type twistPoint struct {
X, Y, Z, T gfP2
}
var twistB = &gfP2{
gfP{0x75046774386b8d71, 0x5bd0854a46d36cf8, 0x664327a1d41c8414, 0x96c9abb932eeb2f},
gfP{0xb94f760fb4c5ee14, 0xdae9f8f24c3b6eb4, 0x77a675d2e52f4fe4, 0x736f31b09116c66b},
}
// twistGen is the generator of group G₂.
var twistGen = &twistPoint{
gfP2{
gfP{0x402c4ab7139e1404, 0xce1c368a183d85a4, 0xd67cf9a6cb8d3983, 0x3cf246bbc2a9fbe8},
gfP{0x88f9f11da7cdc184, 0x18293f95d69509d3, 0xb5ce0c55a735d5a1, 0x15134189bfd45a0},
},
gfP2{
gfP{0xbfac7d731e9e87a2, 0xa50bb8007962e441, 0xafe910a4e8270556, 0x5075c5429d69159a},
gfP{0xc2e07c1463ea9e56, 0xee4442052072ebd2, 0x561a519486036937, 0x5bd9394cc0d2cce},
},
gfP2{*newGFp(0), *newGFp(1)},
gfP2{*newGFp(0), *newGFp(1)},
}
func (c *twistPoint) String() string {
c.MakeAffine()
x, y := gfP2Decode(&c.X), gfP2Decode(&c.Y)
return "(" + x.String() + ", " + y.String() + ")"
}
func (c *twistPoint) Set(a *twistPoint) {
c.X.Set(&a.X)
c.Y.Set(&a.Y)
c.Z.Set(&a.Z)
c.T.Set(&a.T)
}
// IsOnCurve returns true iff c is on the curve.
func (c *twistPoint) IsOnCurve() bool {
c.MakeAffine()
if c.IsInfinity() {
return true
}
y2, x3 := &gfP2{}, &gfP2{}
y2.Square(&c.Y)
x3.Square(&c.X).Mul(x3, &c.X).Add(x3, twistB)
return *y2 == *x3
}
func (c *twistPoint) SetInfinity() {
c.X.SetZero()
c.Y.SetOne()
c.Z.SetZero()
c.T.SetZero()
}
func (c *twistPoint) IsInfinity() bool {
return c.Z.IsZero()
}
func (c *twistPoint) Add(a, b *twistPoint) {
// For additional comments, see the same function in curve.go.
if a.IsInfinity() {
c.Set(b)
return
}
if b.IsInfinity() {
c.Set(a)
return
}
// See http://hyperelliptic.org/EFD/g1p/auto-code/shortw/jacobian-0/addition/add-2007-bl.op3
z12 := (&gfP2{}).Square(&a.Z)
z22 := (&gfP2{}).Square(&b.Z)
u1 := (&gfP2{}).Mul(&a.X, z22)
u2 := (&gfP2{}).Mul(&b.X, z12)
t := (&gfP2{}).Mul(&b.Z, z22)
s1 := (&gfP2{}).Mul(&a.Y, t)
t.Mul(&a.Z, z12)
s2 := (&gfP2{}).Mul(&b.Y, t)
h := (&gfP2{}).Sub(u2, u1)
xEqual := h.IsZero()
t.Add(h, h)
i := (&gfP2{}).Square(t)
j := (&gfP2{}).Mul(h, i)
t.Sub(s2, s1)
yEqual := t.IsZero()
if xEqual && yEqual {
c.Double(a)
return
}
r := (&gfP2{}).Add(t, t)
v := (&gfP2{}).Mul(u1, i)
t4 := (&gfP2{}).Square(r)
t.Add(v, v)
t6 := (&gfP2{}).Sub(t4, j)
c.X.Sub(t6, t)
t.Sub(v, &c.X) // t7
t4.Mul(s1, j) // t8
t6.Add(t4, t4) // t9
t4.Mul(r, t) // t10
c.Y.Sub(t4, t6)
t.Add(&a.Z, &b.Z) // t11
t4.Square(t) // t12
t.Sub(t4, z12) // t13
t4.Sub(t, z22) // t14
c.Z.Mul(t4, h)
}
func (c *twistPoint) Double(a *twistPoint) {
// See http://hyperelliptic.org/EFD/g1p/auto-code/shortw/jacobian-0/doubling/dbl-2009-l.op3
A := (&gfP2{}).Square(&a.X)
B := (&gfP2{}).Square(&a.Y)
C := (&gfP2{}).Square(B)
t := (&gfP2{}).Add(&a.X, B)
t2 := (&gfP2{}).Square(t)
t.Sub(t2, A)
t2.Sub(t, C)
d := (&gfP2{}).Add(t2, t2)
t.Add(A, A)
e := (&gfP2{}).Add(t, A)
f := (&gfP2{}).Square(e)
t.Add(d, d)
c.X.Sub(f, t)
t.Add(C, C)
t2.Add(t, t)
t.Add(t2, t2)
c.Y.Sub(d, &c.X)
t2.Mul(e, &c.Y)
c.Y.Sub(t2, t)
t.Mul(&a.Y, &a.Z)
c.Z.Add(t, t)
}
func (c *twistPoint) Mul(a *twistPoint, scalar *big.Int) {
sum, t := &twistPoint{}, &twistPoint{}
for i := scalar.BitLen(); i >= 0; i-- {
t.Double(sum)
if scalar.Bit(i) != 0 {
sum.Add(t, a)
} else {
sum.Set(t)
}
}
c.Set(sum)
}
func (c *twistPoint) MakeAffine() {
if c.Z.IsOne() {
return
} else if c.Z.IsZero() {
c.X.SetZero()
c.Y.SetOne()
c.T.SetZero()
return
}
zInv := (&gfP2{}).Invert(&c.Z)
t := (&gfP2{}).Mul(&c.Y, zInv)
zInv2 := (&gfP2{}).Square(zInv)
c.Y.Mul(t, zInv2)
t.Mul(&c.X, zInv2)
c.X.Set(t)
c.Z.SetOne()
c.T.SetOne()
}
func (c *twistPoint) Neg(a *twistPoint) {
c.X.Set(&a.X)
c.Y.Neg(&a.Y)
c.Z.Set(&a.Z)
c.T.SetZero()
}
func (c *twistPoint) Frobenius(a *twistPoint) (*twistPoint, error) {
// We have to convert a from the sextic twist
// to the full GF(p^12) group, apply the Frobenius there, and convert
// back.
// The twist isomorphism is (X', Y') -> (xω², yω³). If we consider just
// X for a moment, then after applying the Frobenius, we have x̄ω^(2p)
// where x̄ is the conjugate of X. If we are going to apply the inverse
// isomorphism we need a value with a single coefficient of ω² so we
// rewrite this as x̄ω^(2p-2)ω². ξ⁶ = ω and, due to the construction of
// p, 2p-2 is a multiple of six. Therefore we can rewrite as
// x̄ξ^((p-1)/3)ω² and applying the inverse isomorphism eliminates the
// ω².
// A similar argument can be made for the Y value.
if !a.Z.IsOne() {
return nil, errors.New("a needs to be in affine coordinates")
}
c.X.Conjugate(&(a.X))
c.X.Mul(&(c.X), xiToPMinus1Over3)
c.Y.Conjugate(&(a.Y))
c.Y.Mul(&(c.Y), xiToPMinus1Over2)
c.Z.SetOne()
c.T.SetOne()
return c, nil
} | twist.go | 0.763219 | 0.435841 | twist.go | starcoder |
package decode
import (
"fmt"
"math"
"github.com/docker/go-units"
"github.com/vmware/govmomi/vim25/types"
"github.com/vmware/vic/lib/apiservers/service/models"
)
func FromValueBytesMetric(m *models.ValueBytesMetric) string {
v := float64(m.Value.Value)
var bytes float64
switch m.Value.Units {
case models.ValueBytesMetricUnitsB:
bytes = v
case models.ValueBytesMetricUnitsKB:
bytes = v * float64(units.KB)
case models.ValueBytesMetricUnitsMB:
bytes = v * float64(units.MB)
case models.ValueBytesMetricUnitsGB:
bytes = v * float64(units.GB)
case models.ValueBytesMetricUnitsTB:
bytes = v * float64(units.TB)
case models.ValueBytesMetricUnitsPB:
bytes = v * float64(units.PB)
}
return fmt.Sprintf("%d B", int64(bytes))
}
func MBFromValueBytes(m *models.ValueBytes) *int {
if m == nil {
return nil
}
v := float64(m.Value.Value)
var mbs float64
switch m.Value.Units {
case models.ValueBytesUnitsB:
mbs = v / float64(units.MiB)
case models.ValueBytesUnitsKiB:
mbs = v / (float64(units.MiB) / float64(units.KiB))
case models.ValueBytesUnitsMiB:
mbs = v
case models.ValueBytesUnitsGiB:
mbs = v * (float64(units.GiB) / float64(units.MiB))
case models.ValueBytesUnitsTiB:
mbs = v * (float64(units.TiB) / float64(units.MiB))
case models.ValueBytesUnitsPiB:
mbs = v * (float64(units.PiB) / float64(units.MiB))
}
i := int(math.Ceil(mbs))
return &i
}
func MHzFromValueHertz(m *models.ValueHertz) *int {
if m == nil {
return nil
}
v := float64(m.Value.Value)
var mhzs float64
switch m.Value.Units {
case models.ValueHertzUnitsHz:
mhzs = v / float64(units.MB)
case models.ValueHertzUnitsKHz:
mhzs = v / (float64(units.MB) / float64(units.KB))
case models.ValueHertzUnitsMHz:
mhzs = v
case models.ValueHertzUnitsGHz:
mhzs = v * (float64(units.GB) / float64(units.MB))
}
i := int(math.Ceil(mhzs))
return &i
}
func FromShares(m *models.Shares) *types.SharesInfo {
if m == nil {
return nil
}
var level types.SharesLevel
switch types.SharesLevel(m.Level) {
case types.SharesLevelLow:
level = types.SharesLevelLow
case types.SharesLevelNormal:
level = types.SharesLevelNormal
case types.SharesLevelHigh:
level = types.SharesLevelHigh
default:
level = types.SharesLevelCustom
}
return &types.SharesInfo{
Level: level,
Shares: int32(m.Number),
}
}
func FromValueBits(m *models.ValueBits) int {
return int(m.Value.Value)
} | lib/apiservers/service/restapi/handlers/decode/resources.go | 0.722135 | 0.456107 | resources.go | starcoder |
package profile
import "math"
const (
carea = 1. // area of profile [m²]
ztop = 0. // elevation of top of profile [m]
nsl = 50 // number of profile sublayers
geom = true // use geometric layering
)
// State holds the dynamic state for a profile, that can be subdivided into multiple layers for numerical applications
type State struct {
PM map[int]*rPM // material properties
t, tl, q, ql, p map[int]float64 // state variables t (theta) soil moisture content; q specific humdity (gas-filled pore space moiture content); p (psi) matric potential
dz, cz, vol, K map[int]float64 // structure
}
// WaterContentProfile returns the State's water content with depth
func (ps *State) WaterContentProfile() (t, z []float64) {
t, z = make([]float64, nsl), make([]float64, nsl)
for i := 1; i <= nsl; i++ {
z[i-1] = ps.cz[i]
t[i-1] = ps.t[i]
}
return
}
// Initialize state
func (ps *State) Initialize(p Profile, initSe float64, cellCenter bool) {
// set dimensions
z := ps.buildSubLayers(p.D[len(p.D)], geom)
ps.vol, ps.dz = make(map[int]float64, nsl+1), make(map[int]float64, nsl+1)
ps.cz = make(map[int]float64, nsl+1)
ps.vol[0] = 0.
for i := 0; i <= nsl; i++ {
ps.dz[i] = z[i+1] - z[i]
if i > 0 {
ps.vol[i] = carea * ps.dz[i]
}
}
for i := 1; i <= nsl+1; i++ {
ps.cz[i] = z[i] + ps.dz[i]/2. // cell center (as depth from top), adding ghost cell below model for boundary conditions
}
if cellCenter {
// adjust cell centered finite volume nodal distances at boundaries
for i := 0; i <= nsl; i++ {
ps.dz[i] = ps.cz[i+1] - ps.cz[i]
}
}
// inital conditions
ps.PM, ps.p = make(map[int]*rPM, nsl+2), make(map[int]float64, nsl+2)
ps.t, ps.tl, ps.q, ps.ql, ps.K = make(map[int]float64, nsl+1), make(map[int]float64, nsl+1), make(map[int]float64, nsl+1), make(map[int]float64, nsl+1), make(map[int]float64, nsl+1)
ps.p[0] = 0.
ps.PM[0] = newPM(p.GetPorousMedium(0.))
for i := 1; i <= nsl+1; i++ {
pm := newPM(p.GetPorousMedium(ps.cz[i]))
ps.PM[i] = pm
ps.t[i] = pm.GetThetaSe(initSe)
ps.tl[i] = ps.t[i]
ps.p[i] = pm.GetPsi(ps.t[i])
ps.K[i] = pm.GetK(ps.t[i])
ps.q[i] = qp * math.Exp(mw*ps.p[i]/r/ts) // ps.PM[i].GetSpecificHumidity(ps.p[i])
ps.ql[i] = ps.q[i]
// ps.h[i] = ps.p[i] - ps.cz[i]*g // could set ps.h[nsl+1] for bottom constant head bc (not used in Newton Raphson)
}
// reconfigure cz to elevation
for i := 1; i <= nsl+1; i++ {
ps.cz[i] = ztop - ps.cz[i] // cell center
}
}
func (ps *State) buildSubLayers(depth float64, geom bool) map[int]float64 {
z := make(map[int]float64, nsl+2)
z[0] = 0.0 // ghost cell
z[1] = 0.0 // top of profile
if geom { // geometric distribution
sum := 0.0
for i := 0; i <= nsl; i++ {
sum += float64(i * i)
}
dz := depth / sum
for i := 1; i <= nsl; i++ {
z[i+1] = z[i] + dz*float64(i*i)
}
} else { // linear distribution
dz := depth / float64(nsl)
for i := 1; i <= nsl; i++ {
z[i+1] = z[i] + dz
}
}
return z
}
func (ps *State) reset() {
for i := range ps.t {
ps.t[i] = ps.tl[i]
ps.p[i] = ps.PM[i].GetPsi(ps.t[i])
ps.q[i] = ps.ql[i]
}
}
func (ps *State) save() {
for i := range ps.t {
ps.tl[i] = ps.t[i]
ps.ql[i] = ps.q[i]
}
}
func (ps *State) setToInfiltrating() {
ps.p[0] = math.Min(ps.PM[1].He, ps.PM[0].He)
ps.t[0] = ps.PM[0].GetTheta(ps.p[0])
ps.p[1] = ps.p[0]
ps.t[1] = ps.t[0]
ps.tl[1] = ps.t[0]
ps.q[1] = qp * math.Exp(mw*ps.p[1]/r/ts) // ps.PM[1].GetSpecificHumidity(ps.p[1])
}
func (ps *State) setToFreeDraining() {
ps.p[nsl+1] = ps.p[nsl]
// ps.h[nsl+1] = ps.p[nsl+1] - ps.cz[nsl+1]*g
ps.t[nsl+1] = ps.t[nsl]
ps.K[nsl+1] = ps.K[nsl]
ps.q[nsl+1] = ps.q[nsl]
} | profile/state.go | 0.635788 | 0.480905 | state.go | starcoder |
package iso20022
// Information about a securities account and its characteristics.
type InvestmentAccount52 struct {
// Name of the account. It provides an additional means of identification, and is designated by the account servicer in agreement with the account owner.
Name *Max35Text `xml:"Nm,omitempty"`
// Supplementary registration information applying to a specific block of units for dealing and reporting purposes. The supplementary registration information may be used when all the units are registered, for example, to a funds supermarket, but holdings for each investor have to reconciled individually.
Designation *Max35Text `xml:"Dsgnt,omitempty"`
// Legal form of the fund, for example, UCITS, SICAV, OEIC, Unit Trust, and FCP.
FundType *Max35Text `xml:"FndTp,omitempty"`
// Name of the investment fund family.
FundFamilyName *Max350Text `xml:"FndFmlyNm,omitempty"`
// Detailed information about the investment fund associated to the account.
SecurityDetails *FinancialInstrument45 `xml:"SctyDtls,omitempty"`
// Owner of the account.
AccountOwner *AccountOwner1Choice `xml:"AcctOwnr,omitempty"`
// Intermediary or other party related to the management of the account. In some markets, when this intermediary is a party acting on behalf of the investor for which it has opened an account at, for example, a central securities depository or international central securities depository, this party is known by the investor as the 'account controller'.
Intermediary []*Intermediary33 `xml:"Intrmy,omitempty"`
// Party that manages the account on behalf of the account owner, that is manages the registration and booking of entries on the account, calculates balances on the account and provides information about the account.
AccountServicer *PartyIdentification70Choice `xml:"AcctSvcr,omitempty"`
}
func (i *InvestmentAccount52) SetName(value string) {
i.Name = (*Max35Text)(&value)
}
func (i *InvestmentAccount52) SetDesignation(value string) {
i.Designation = (*Max35Text)(&value)
}
func (i *InvestmentAccount52) SetFundType(value string) {
i.FundType = (*Max35Text)(&value)
}
func (i *InvestmentAccount52) SetFundFamilyName(value string) {
i.FundFamilyName = (*Max350Text)(&value)
}
func (i *InvestmentAccount52) AddSecurityDetails() *FinancialInstrument45 {
i.SecurityDetails = new(FinancialInstrument45)
return i.SecurityDetails
}
func (i *InvestmentAccount52) AddAccountOwner() *AccountOwner1Choice {
i.AccountOwner = new(AccountOwner1Choice)
return i.AccountOwner
}
func (i *InvestmentAccount52) AddIntermediary() *Intermediary33 {
newValue := new (Intermediary33)
i.Intermediary = append(i.Intermediary, newValue)
return newValue
}
func (i *InvestmentAccount52) AddAccountServicer() *PartyIdentification70Choice {
i.AccountServicer = new(PartyIdentification70Choice)
return i.AccountServicer
} | InvestmentAccount52.go | 0.684159 | 0.411702 | InvestmentAccount52.go | starcoder |
package bson
import (
"fmt"
"math"
)
type BsonIterator struct {
raw []byte
length int
offset int
// current field
elementLen int
keyLen int
value []byte
}
func bytesToInt32(b []byte) int32 {
if len(b) < 4 {
panic("bytesToInt32: len([]byte) < 4")
}
return int32(uint32(b[0]) | (uint32(b[1]) << 8) | (uint32(b[2]) << 16) | (uint32(b[3]) << 24))
}
func bytesToInt64(b []byte) int64 {
if len(b) < 8 {
panic("bytesToInt64: len([]byte) < 8")
}
return int64(uint64(b[0]) | (uint64(b[1]) << 8) | (uint64(b[2]) << 16) | (uint64(b[3]) << 24) |
(uint64(b[4]) << 32) | (uint64(b[5]) << 40) | (uint64(b[6]) << 48) | (uint64(b[7]) << 56))
}
func bytesToFloat64(b []byte) float64 {
if len(b) < 8 {
panic("bytesToFloat64: len([]byte) < 8")
}
return math.Float64frombits(uint64(bytesToInt64(b)))
}
func NewBsonIterator(bson *Bson) *BsonIterator {
if bson == nil {
panic("null bson")
}
raw := bson.Raw()
length := int(bytesToInt32(raw))
return &BsonIterator{
raw: raw,
length: length,
offset: 4,
}
}
func (it *BsonIterator) Reset() {
it.offset = 4
it.elementLen = 0
it.keyLen = 0
it.value = nil
}
// include '0x00'
func cstringLength(s []byte) int {
len := len(s)
if len == 0 {
panic("no cstring")
}
cstringLen := 0
for i := 0; i < len; i++ {
if s[i] == 0x00 {
cstringLen = i + 1
break
}
}
if cstringLen < 1 || s[cstringLen-1] != 0x00 {
panic("invalid cstring")
}
return cstringLen
}
func (it *BsonIterator) More() bool {
t := BsonType(it.raw[it.offset+it.elementLen])
return t != BsonTypeEOD
}
func (it *BsonIterator) Next() bool {
it.offset += it.elementLen
t := BsonType(it.raw[it.offset])
if t == BsonTypeEOD {
it.elementLen = 0
return false
}
fieldOffset := 1 // skip field type
// calc key length
it.keyLen = cstringLength(it.raw[it.offset+1:])
fieldOffset += it.keyLen
it.value = it.raw[it.offset+fieldOffset:]
// calc value length
switch t {
case BsonTypeFloat64:
fieldOffset += 8
case BsonTypeString:
fieldOffset += int(bytesToInt32(it.value)) + 4
case BsonTypeBson:
fallthrough
case BsonTypeArray:
fieldOffset += int(bytesToInt32(it.value))
case BsonTypeBinary:
fieldOffset += int(bytesToInt32(it.value)) + 5
case BsonTypeObjectId:
fieldOffset += 12
case BsonTypeBool:
fieldOffset += 1
case BsonTypeDate:
fieldOffset += 8
case BsonTypeNull:
// no value
case BsonTypeRegEx:
patternLen := cstringLength(it.value)
optionsLen := cstringLength(it.value[patternLen:])
fieldOffset += patternLen + optionsLen
case BsonTypeInt32:
fieldOffset += 4
case BsonTypeTimestamp:
fieldOffset += 8
case BsonTypeInt64:
fieldOffset += 8
case BsonTypeMaxKey:
// no value
case BsonTypeMinKey:
// no value
default:
panic(fmt.Sprintf("invalid bson type: %v", t))
}
it.elementLen = fieldOffset
return true
}
func (it *BsonIterator) BsonType() BsonType {
return BsonType(it.raw[it.offset])
}
func (it *BsonIterator) Name() string {
return string(it.raw[it.offset+1 : it.offset+it.keyLen])
}
func (it *BsonIterator) Value() interface{} {
switch it.BsonType() {
case BsonTypeFloat64:
return it.Float64()
case BsonTypeString:
return it.UTF8String()
case BsonTypeBson:
return it.Bson()
case BsonTypeArray:
return it.BsonArray()
case BsonTypeBinary:
return it.Binary()
case BsonTypeObjectId:
return it.ObjectId()
case BsonTypeBool:
return it.Bool()
case BsonTypeDate:
return it.Date()
case BsonTypeNull:
return nil
case BsonTypeRegEx:
return it.RegEx()
case BsonTypeInt32:
return it.Int32()
case BsonTypeTimestamp:
return it.Timestamp()
case BsonTypeInt64:
return it.Int64()
case BsonTypeMaxKey:
return MaxKey
case BsonTypeMinKey:
return MinKey
default:
panic(fmt.Errorf("invalid bson type: %v", it.BsonType()))
}
}
func (it *BsonIterator) Float64() float64 {
return bytesToFloat64(it.value)
}
func (it *BsonIterator) UTF8String() string {
len := bytesToInt32(it.value)
return string(it.value[4 : len+3])
}
func (it *BsonIterator) Bson() *Bson {
len := bytesToInt32(it.value)
return &Bson{raw: it.value[:len]}
}
func (it *BsonIterator) BsonArray() *BsonArray {
len := bytesToInt32(it.value)
return &BsonArray{bson: Bson{raw: it.value[:len]}}
}
func (it *BsonIterator) Binary() Binary {
len := bytesToInt32(it.value)
return Binary{Subtype: BinaryType(it.value[4]), Data: it.value[5 : len+5]}
}
func (it *BsonIterator) ObjectId() ObjectId {
return ObjectId(it.value[:12])
}
func (it *BsonIterator) Bool() bool {
return it.value[0] == 0x01
}
func (it *BsonIterator) Date() Date {
return Date(it.Int64())
}
func (it *BsonIterator) RegEx() RegEx {
patternLen := cstringLength(it.value)
pattern := string(it.value[:patternLen-1])
optionsLen := cstringLength(it.value[patternLen:])
options := string(it.value[patternLen : patternLen+optionsLen-1])
return RegEx{Pattern: pattern, Options: options}
}
func (it *BsonIterator) Int32() int32 {
return bytesToInt32(it.value)
}
func (it *BsonIterator) Timestamp() Timestamp {
inc := bytesToInt32(it.value)
sec := bytesToInt32(it.value[4:])
return Timestamp{Increment: inc, Second: sec}
}
func (it *BsonIterator) Int64() int64 {
return bytesToInt64(it.value)
} | bson/bsoniterator.go | 0.639511 | 0.44089 | bsoniterator.go | starcoder |
package plan
import (
"io"
"reflect"
"github.com/opentracing/opentracing-go"
"github.com/dolthub/go-mysql-server/sql"
)
// An IndexedJoin is a join that uses index lookups for the secondary table.
type IndexedJoin struct {
// The primary and secondary table nodes. The normal meanings of Left and
// Right in BinaryNode aren't necessarily meaningful here -- the Left node is always the primary table, and the Right
// node is always the secondary. These may or may not correspond to the left and right tables in the written query.
BinaryNode
// The join condition.
Cond sql.Expression
// The type of join. Left and right refer to the lexical position in the written query, not primary / secondary. In
// the case of a right join, the right table will always be the primary.
joinType JoinType
scopeLen int
}
// JoinType returns the join type for this indexed join
func (ij *IndexedJoin) JoinType() JoinType {
return ij.joinType
}
func NewIndexedJoin(left, right sql.Node, joinType JoinType, cond sql.Expression, scopeLen int) *IndexedJoin {
return &IndexedJoin{
BinaryNode: BinaryNode{left, right},
joinType: joinType,
Cond: cond,
scopeLen: scopeLen,
}
}
func (ij *IndexedJoin) String() string {
pr := sql.NewTreePrinter()
joinType := ""
switch ij.joinType {
case JoinTypeLeft:
joinType = "Left"
case JoinTypeRight:
joinType = "Right"
}
_ = pr.WriteNode("%sIndexedJoin(%s)", joinType, ij.Cond)
_ = pr.WriteChildren(ij.left.String(), ij.right.String())
return pr.String()
}
func (ij *IndexedJoin) DebugString() string {
pr := sql.NewTreePrinter()
joinType := ""
switch ij.joinType {
case JoinTypeLeft:
joinType = "Left"
case JoinTypeRight:
joinType = "Right"
}
_ = pr.WriteNode("%sIndexedJoin(%s)", joinType, sql.DebugString(ij.Cond))
_ = pr.WriteChildren(sql.DebugString(ij.left), sql.DebugString(ij.right))
return pr.String()
}
func (ij *IndexedJoin) Schema() sql.Schema {
return append(ij.left.Schema(), ij.right.Schema()...)
}
func (ij *IndexedJoin) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error) {
return indexedJoinRowIter(ctx, row, ij.left, ij.right, ij.Cond, ij.joinType, ij.scopeLen)
}
func (ij *IndexedJoin) WithChildren(children ...sql.Node) (sql.Node, error) {
if len(children) != 2 {
return nil, sql.ErrInvalidChildrenNumber.New(ij, len(children), 2)
}
return NewIndexedJoin(children[0], children[1], ij.joinType, ij.Cond, ij.scopeLen), nil
}
func indexedJoinRowIter(
ctx *sql.Context,
parentRow sql.Row,
left sql.Node,
right sql.Node,
cond sql.Expression,
joinType JoinType,
scopeLen int,
) (sql.RowIter, error) {
var leftName, rightName string
if leftTable, ok := left.(sql.Nameable); ok {
leftName = leftTable.Name()
} else {
leftName = reflect.TypeOf(left).String()
}
if rightTable, ok := right.(sql.Nameable); ok {
rightName = rightTable.Name()
} else {
rightName = reflect.TypeOf(right).String()
}
span, ctx := ctx.Span("plan.indexedJoin", opentracing.Tags{
"left": leftName,
"right": rightName,
})
l, err := left.RowIter(ctx, parentRow)
if err != nil {
span.Finish()
return nil, err
}
return sql.NewSpanIter(span, &indexedJoinIter{
parentRow: parentRow,
primary: l,
secondaryProvider: right,
ctx: ctx,
cond: cond,
joinType: joinType,
rowSize: len(parentRow) + len(left.Schema()) + len(right.Schema()),
scopeLen: scopeLen,
}), nil
}
// indexedJoinIter is an iterator that iterates over every row in the primary table and performs an index lookup in
// the secondary table for each value
type indexedJoinIter struct {
parentRow sql.Row
primary sql.RowIter
primaryRow sql.Row
secondaryProvider sql.Node
secondary sql.RowIter
cond sql.Expression
joinType JoinType
ctx *sql.Context
foundMatch bool
rowSize int
scopeLen int
}
func (i *indexedJoinIter) loadPrimary() error {
if i.primaryRow == nil {
r, err := i.primary.Next()
if err != nil {
return err
}
i.primaryRow = i.parentRow.Append(r)
i.foundMatch = false
}
return nil
}
func (i *indexedJoinIter) loadSecondary() (sql.Row, error) {
if i.secondary == nil {
rowIter, err := i.secondaryProvider.RowIter(i.ctx, i.primaryRow)
if err != nil {
return nil, err
}
i.secondary = rowIter
}
secondaryRow, err := i.secondary.Next()
if err != nil {
if err == io.EOF {
i.secondary = nil
i.primaryRow = nil
return nil, io.EOF
}
return nil, err
}
return secondaryRow, nil
}
func (i *indexedJoinIter) Next() (sql.Row, error) {
for {
if err := i.loadPrimary(); err != nil {
return nil, err
}
primary := i.primaryRow
secondary, err := i.loadSecondary()
if err != nil {
if err == io.EOF {
if !i.foundMatch && (i.joinType == JoinTypeLeft || i.joinType == JoinTypeRight) {
row := i.buildRow(primary, nil)
return i.removeParentRow(row), nil
}
continue
}
return nil, err
}
row := i.buildRow(primary, secondary)
matches, err := conditionIsTrue(i.ctx, row, i.cond)
if err != nil {
return nil, err
}
if !matches {
continue
}
i.foundMatch = true
return i.removeParentRow(row), nil
}
}
func (i *indexedJoinIter) removeParentRow(r sql.Row) sql.Row {
copy(r[i.scopeLen:], r[len(i.parentRow):])
r = r[:len(r)-len(i.parentRow)+i.scopeLen]
return r
}
func conditionIsTrue(ctx *sql.Context, row sql.Row, cond sql.Expression) (bool, error) {
v, err := cond.Eval(ctx, row)
if err != nil {
return false, err
}
// Expressions containing nil evaluate to nil, not false
return v == true, nil
}
// buildRow builds the result set row using the rows from the primary and secondary tables
func (i *indexedJoinIter) buildRow(primary, secondary sql.Row) sql.Row {
row := make(sql.Row, i.rowSize)
copy(row, primary)
copy(row[len(primary):], secondary)
return row
}
func (i *indexedJoinIter) Close(ctx *sql.Context) (err error) {
if i.primary != nil {
if err = i.primary.Close(ctx); err != nil {
if i.secondary != nil {
_ = i.secondary.Close(ctx)
}
return err
}
}
if i.secondary != nil {
err = i.secondary.Close(ctx)
i.secondary = nil
}
return err
} | sql/plan/indexed_join.go | 0.63341 | 0.466785 | indexed_join.go | starcoder |
package hole
import (
"math"
"math/rand"
"strconv"
"strings"
)
type Node struct {
op byte
value int
left, right *Node
}
func asNode(val int) *Node { return &Node{op: '=', value: val} }
func randInt(a, b int) int { return rand.Intn(b-a+1) + a }
func expand(node *Node) {
val := node.value
var left, right int
switch node.op = "+-*/"[rand.Intn(4)]; node.op {
case '+':
left = randInt(0, val)
right = val - left
case '-':
left = randInt(val, math.MaxInt16)
right = left - val
case '*':
if val == 0 {
left = randInt(0, math.MaxInt16)
right = 0
} else {
factors := []int{1}
for i := 2; i*i <= val; i++ {
if val%i == 0 {
factors = append(factors, i)
}
}
left = factors[rand.Intn(len(factors))]
right = val / left
}
if rand.Intn(2) == 1 {
left, right = right, left
}
case '/':
if val == 0 {
left = 0
right = randInt(1, math.MaxInt16)
} else {
right = randInt(1, math.MaxInt16/val)
left = val * right
}
}
node.left = asNode(left)
node.right = asNode(right)
}
func expandLeft(init *Node, count int) {
for ; count > 0; count-- {
expand(init)
init = init.left
}
}
func expandRight(init *Node, count int) {
for ; count > 0; count-- {
expand(init)
init = init.right
}
}
func expandRand(init *Node, count int) {
valueNodes := []*Node{init}
for nodesCount := 1; nodesCount <= count; nodesCount++ {
nodeIdx := rand.Intn(nodesCount)
node := valueNodes[nodeIdx]
expand(node)
valueNodes[nodeIdx] = node.left
valueNodes = append(valueNodes, node.right)
}
}
func writeNode(sb *strings.Builder, node *Node) {
if node.op == '=' {
if sb.Len() > 0 {
sb.WriteByte(' ')
}
sb.WriteString(strconv.Itoa(node.value))
} else {
writeNode(sb, node.left)
writeNode(sb, node.right)
sb.WriteByte(' ')
sb.WriteByte(node.op)
}
}
func genExpr(init int, expander func(*Node, int), expandCount int) *Node {
node := asNode(init)
expander(node, expandCount)
return node
}
func reversePolishNotation() ([]string, string) {
const tests = 20
exprs := [tests]*Node{
genExpr(randInt(1, math.MaxInt16), expandLeft, randInt(16, 31)),
genExpr(randInt(1, math.MaxInt16), expandRight, randInt(16, 31)),
genExpr(randInt(1, math.MaxInt16), expandRight, 0),
genExpr(0, expandRand, randInt(16, 31)),
}
for i := 4; i < tests; i++ {
exprs[i] = genExpr(randInt(1, math.MaxInt16), expandRand, randInt(1, 31))
}
rand.Shuffle(len(exprs), func(i, j int) {
exprs[i], exprs[j] = exprs[j], exprs[i]
})
args := make([]string, tests)
var answer strings.Builder
for i, expr := range exprs {
var arg strings.Builder
writeNode(&arg, expr)
args[i] = arg.String()
if i > 0 {
answer.WriteByte('\n')
}
answer.WriteString(strconv.Itoa(expr.value))
}
return args, answer.String()
} | hole/reverse-polish-notation.go | 0.505371 | 0.443661 | reverse-polish-notation.go | starcoder |
package blurhash
import (
"fmt"
"github.com/buckket/go-blurhash/base83"
"image"
"image/color"
"math"
)
// An InvalidHashError occurs when the given hash is either too short or the length does not match its size flag.
type InvalidHashError string
func (e InvalidHashError) Error() string {
return fmt.Sprintf("blurhash: %s", string(e))
}
// Components decodes and returns the number of x and y components in the given BlurHash.
func Components(hash string) (xComponents, yComponents int, err error) {
if len(hash) < 6 {
return 0, 0, InvalidHashError("hash is invalid (too short)")
}
sizeFlag, err := base83.Decode(string(hash[0]))
if err != nil {
return 0, 0, err
}
yComponents = (sizeFlag / 9) + 1
xComponents = (sizeFlag % 9) + 1
if len(hash) != 4+2*xComponents*yComponents {
return 0, 0, InvalidHashError("hash is invalid (length mismatch)")
}
return xComponents, yComponents, nil
}
// Decode generates an image of the given BlurHash with a size of width and height.
// Punch is a multiplier that adjusts the contrast of the resulting image.
func Decode(hash string, width, height, punch int) (image.Image, error) {
xComp, yComp, err := Components(hash)
if err != nil {
return nil, err
}
quantisedMaximumValue, err := base83.Decode(string(hash[1]))
if err != nil {
return nil, err
}
maximumValue := (float64(quantisedMaximumValue) + 1) / 166
if punch == 0 {
punch = 1
}
colors := make([][3]float64, xComp*yComp)
for i := range colors {
if i == 0 {
value, err := base83.Decode(hash[2:6])
if err != nil {
return nil, err
}
colors[i] = decodeDC(value)
} else {
value, err := base83.Decode(hash[4+i*2 : 6+i*2])
if err != nil {
return nil, err
}
colors[i] = decodeAC(value, maximumValue*float64(punch))
}
}
img := image.NewNRGBA(image.Rect(0, 0, width, height))
for y := 0; y < height; y++ {
for x := 0; x < width; x++ {
var r, g, b float64
for j := 0; j < yComp; j++ {
for i := 0; i < xComp; i++ {
basis := math.Cos(math.Pi*float64(x)*float64(i)/float64(width)) *
math.Cos(math.Pi*float64(y)*float64(j)/float64(height))
pcolor := colors[i+j*xComp]
r += pcolor[0] * basis
g += pcolor[1] * basis
b += pcolor[2] * basis
}
}
img.SetNRGBA(x, y, color.NRGBA{R: uint8(linearTosRGB(r)), G: uint8(linearTosRGB(g)), B: uint8(linearTosRGB(b)), A: 255})
}
}
return img, nil
}
func decodeDC(value int) [3]float64 {
return [3]float64{sRGBToLinear(value >> 16), sRGBToLinear(value >> 8 & 255), sRGBToLinear(value & 255)}
}
func decodeAC(value int, maximumValue float64) [3]float64 {
quantR := math.Floor(float64(value) / (19 * 19))
quantG := math.Mod(math.Floor(float64(value)/19), 19)
quantB := math.Mod(float64(value), 19)
sp := func(quant float64) float64 {
return signPow((quant-9)/9, 2.0) * maximumValue
}
return [3]float64{sp(quantR), sp(quantG), sp(quantB)}
} | vendor/github.com/buckket/go-blurhash/decode.go | 0.86792 | 0.453141 | decode.go | starcoder |
// Package sgu implements the Spatial Gating Unit (SGU).
// Reference: `Pay Attention to MLPs` by Liu et al, 2021 (https://arxiv.org/pdf/2105.08050.pdf)
package sgu
import (
"encoding/gob"
"github.com/nlpodyssey/spago/ag"
"github.com/nlpodyssey/spago/initializers"
"github.com/nlpodyssey/spago/mat/float"
"github.com/nlpodyssey/spago/mat/rand"
"github.com/nlpodyssey/spago/nn"
"github.com/nlpodyssey/spago/nn/activation"
"github.com/nlpodyssey/spago/nn/convolution/conv1x1"
"github.com/nlpodyssey/spago/nn/normalization/layernorm"
)
// Model contains the serializable parameters.
type Model struct {
nn.Module
Config Config
Norm *layernorm.Model
Proj *conv1x1.Model
Act *activation.Model
}
var _ nn.Model = &Model{}
// Config provides configuration parameters for Model.
type Config struct {
Dim int
DimSeq int
InitEps float64
Activation activation.Name
}
func init() {
gob.Register(&Model{})
}
// New returns a new Model initialized to zeros.
func New[T float.DType](config Config) *Model {
dimOut := config.Dim / 2
m := &Model{
Config: config,
Norm: layernorm.New[T](dimOut, 1e-12),
Proj: conv1x1.New[T](conv1x1.Config{
InputChannels: config.DimSeq,
OutputChannels: config.DimSeq,
}),
Act: nil,
}
if config.Activation != activation.Identity {
m.Act = activation.New(config.Activation)
}
return m
}
// Initialize set the projection weights as near-zero values and the biases as ones to improve training stability.
func (m *Model) Initialize(seed uint64) {
r := rand.NewLockedRand(seed)
eps := m.Config.InitEps / float64(m.Config.DimSeq)
initializers.Uniform(m.Proj.W.Value(), -eps, eps, r)
initializers.Constant(m.Proj.B.Value(), 1)
}
// Forward performs the forward step for each input node and returns the result.
func (m *Model) Forward(xs ...ag.Node) []ag.Node {
size := xs[0].Value().Size()
halfSize := size / 2
res := make([]ag.Node, len(xs))
gate := make([]ag.Node, len(xs))
for i, x := range xs {
res[i] = ag.Slice(x, 0, 0, halfSize, 1)
gate[i] = ag.Slice(x, halfSize, 0, size, 1)
}
gate = m.Norm.Forward(gate...)
gate = m.Proj.Forward(gate...)
if m.Act != nil {
gate = m.Act.Forward(gate...)
}
y := make([]ag.Node, len(gate))
for i := range y {
y[i] = ag.Prod(gate[i], res[i])
}
return y
} | nn/sgu/model.go | 0.879276 | 0.417093 | model.go | starcoder |
package tvf
import (
"context"
"fmt"
"time"
"github.com/pkg/errors"
"github.com/cube2222/octosql"
"github.com/cube2222/octosql/docs"
"github.com/cube2222/octosql/execution"
"github.com/cube2222/octosql/storage"
)
type MaximumDifferenceWatermarkGenerator struct {
source execution.Node
timeField octosql.VariableName
offset execution.Expression
}
func NewMaximumDifferenceWatermarkGenerator(source execution.Node, timeField octosql.VariableName, offset execution.Expression) *MaximumDifferenceWatermarkGenerator {
return &MaximumDifferenceWatermarkGenerator{
source: source,
timeField: timeField,
offset: offset,
}
}
func (r *MaximumDifferenceWatermarkGenerator) Document() docs.Documentation {
return docs.Section(
"watermark generator: maximal difference",
docs.Body(
docs.Section("Calling", docs.Text("max_diff_watermark(source => \\<Source\\>, time_field => \\<Descriptor\\>, offset => \\<interval\\>)")),
docs.Section("Description", docs.Text("Creating standard watermark that stores watermark value of `<maximal record event time> - given offset.`")),
docs.Section("Example", docs.Text("```\nWITH"+
"\n with_watermark AS (SELECT * FROM max_diff_watermark("+
"\n source=>TABLE(events),"+
"\n time_field=>DESCRIPTOR(time)),"+
"\n offset=>INTERVAL 5 SECONDS) e),"+
"\nSELECT e.team, COUNT(*) as goals\nFROM with_watermark e\nGROUP BY e.team\nTRIGGER COUNTING 100, ON WATERMARK"+
"\n```")),
),
)
}
func (w *MaximumDifferenceWatermarkGenerator) Get(ctx context.Context, variables octosql.Variables, streamID *execution.StreamID) (execution.RecordStream, *execution.ExecutionOutput, error) {
tx := storage.GetStateTransactionFromContext(ctx)
sourceStreamID, err := execution.GetSourceStreamID(tx.WithPrefix(streamID.AsPrefix()), octosql.MakePhantom())
if err != nil {
return nil, nil, errors.Wrap(err, "couldn't get source stream ID")
}
source, execOutput, err := w.source.Get(ctx, variables, sourceStreamID)
if err != nil {
return nil, nil, errors.Wrap(err, "couldn't get source")
}
offset, err := w.offset.ExpressionValue(ctx, variables)
if err != nil {
return nil, nil, errors.Wrap(err, "couldn't get watermark offset")
}
if offset.GetType() != octosql.TypeDuration {
return nil, nil, errors.Errorf("invalid watermark offset type: %v", offset.GetType())
}
ws := &WatermarkGeneratorStream{
streamID: streamID,
source: source,
timeField: w.timeField,
offset: offset.AsDuration(),
}
return ws, execution.NewExecutionOutput(ws, execOutput.NextShuffles, execOutput.TasksToRun), nil // watermark generator stream now indicates new watermark source
}
type WatermarkGeneratorStream struct {
streamID *execution.StreamID
source execution.RecordStream
timeField octosql.VariableName
offset time.Duration
}
var watermarkPrefix = []byte("$watermark$")
func (s *WatermarkGeneratorStream) GetWatermark(ctx context.Context, tx storage.StateTransaction) (time.Time, error) {
return s.getWatermark(tx.WithPrefix(s.streamID.AsPrefix()))
}
func (s *WatermarkGeneratorStream) getWatermark(tx storage.StateTransaction) (time.Time, error) {
watermarkStorage := storage.NewValueState(tx.WithPrefix(watermarkPrefix))
var currentWatermark octosql.Value
err := watermarkStorage.Get(¤tWatermark)
if err == storage.ErrNotFound {
currentWatermark = octosql.MakeTime(time.Time{})
} else if err != nil {
return time.Time{}, errors.Wrap(err, "couldn't get current watermark from storage")
}
return currentWatermark.AsTime(), nil
}
func (s *WatermarkGeneratorStream) Next(ctx context.Context) (*execution.Record, error) {
srcRecord, err := s.source.Next(ctx)
if err != nil {
if err == execution.ErrEndOfStream {
return nil, execution.ErrEndOfStream
}
return nil, errors.Wrap(err, "couldn't get source record")
}
timeValue := srcRecord.Value(s.timeField)
if timeValue.GetType() != octosql.TypeTime {
return nil, fmt.Errorf("couldn't get time field '%v' as time, got: %v", s.timeField.String(), srcRecord.Value(s.timeField))
}
// watermark value stored equals to (max_record_time - offset) that's why we multiply offset by -1
timeValueWithOffset := timeValue.AsTime().Add(-1 * s.offset)
tx := storage.GetStateTransactionFromContext(ctx).WithPrefix(s.streamID.AsPrefix())
currentWatermark, err := s.getWatermark(tx)
if err != nil {
return nil, errors.Wrap(err, "couldn't get current watermark value")
}
if timeValueWithOffset.After(currentWatermark) { // time in current record is bigger than current watermark - update it
watermarkStorage := storage.NewValueState(tx.WithPrefix(watermarkPrefix))
newWatermark := octosql.MakeTime(timeValueWithOffset)
err := watermarkStorage.Set(&newWatermark)
if err != nil {
return nil, errors.Wrap(err, "couldn't set new watermark value in storage")
}
}
srcRecord = execution.NewRecordFromRecord(srcRecord, execution.WithEventTimeField(s.timeField))
return srcRecord, nil
}
func (s *WatermarkGeneratorStream) Close(ctx context.Context, storage storage.Storage) error {
if err := s.source.Close(ctx, storage); err != nil {
return errors.Wrap(err, "couldn't close underlying stream")
}
if err := storage.DropAll(s.streamID.AsPrefix()); err != nil {
return errors.Wrap(err, "couldn't clear storage with streamID prefix")
}
return nil
} | execution/tvf/maximum_difference_watermark_generator.go | 0.769687 | 0.48499 | maximum_difference_watermark_generator.go | starcoder |
package plaid
import (
"encoding/json"
)
// EarningsTotal An object representing both the current pay period and year to date amount for an earning category.
type EarningsTotal struct {
// Commonly used term to describe the line item.
CanonicalDescription NullableString `json:"canonical_description,omitempty"`
// Total amount of the earnings for this pay period
CurrentAmount NullableFloat32 `json:"current_amount,omitempty"`
CurrentPay *Pay `json:"current_pay,omitempty"`
YtdPay *Pay `json:"ytd_pay,omitempty"`
// Total number of hours worked for this pay period
Hours NullableFloat32 `json:"hours,omitempty"`
// The ISO-4217 currency code of the line item. Always `null` if `unofficial_currency_code` is non-null.
IsoCurrencyCode NullableString `json:"iso_currency_code,omitempty"`
// The unofficial currency code associated with the security. Always `null` if `iso_currency_code` is non-`null`. Unofficial currency codes are used for currencies that do not have official ISO currency codes, such as cryptocurrencies and the currencies of certain countries. See the [currency code schema](https://plaid.com/docs/api/accounts#currency-code-schema) for a full listing of supported `iso_currency_code`s.
UnofficialCurrencyCode NullableString `json:"unofficial_currency_code,omitempty"`
// The total year-to-date amount of the earnings
YtdAmount NullableFloat32 `json:"ytd_amount,omitempty"`
AdditionalProperties map[string]interface{}
}
type _EarningsTotal EarningsTotal
// NewEarningsTotal instantiates a new EarningsTotal 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 NewEarningsTotal() *EarningsTotal {
this := EarningsTotal{}
return &this
}
// NewEarningsTotalWithDefaults instantiates a new EarningsTotal 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 NewEarningsTotalWithDefaults() *EarningsTotal {
this := EarningsTotal{}
return &this
}
// GetCanonicalDescription returns the CanonicalDescription field value if set, zero value otherwise (both if not set or set to explicit null).
func (o *EarningsTotal) GetCanonicalDescription() string {
if o == nil || o.CanonicalDescription.Get() == nil {
var ret string
return ret
}
return *o.CanonicalDescription.Get()
}
// GetCanonicalDescriptionOk returns a tuple with the CanonicalDescription field value if set, nil otherwise
// and a boolean to check if the value has been set.
// NOTE: If the value is an explicit nil, `nil, true` will be returned
func (o *EarningsTotal) GetCanonicalDescriptionOk() (*string, bool) {
if o == nil {
return nil, false
}
return o.CanonicalDescription.Get(), o.CanonicalDescription.IsSet()
}
// HasCanonicalDescription returns a boolean if a field has been set.
func (o *EarningsTotal) HasCanonicalDescription() bool {
if o != nil && o.CanonicalDescription.IsSet() {
return true
}
return false
}
// SetCanonicalDescription gets a reference to the given NullableString and assigns it to the CanonicalDescription field.
func (o *EarningsTotal) SetCanonicalDescription(v string) {
o.CanonicalDescription.Set(&v)
}
// SetCanonicalDescriptionNil sets the value for CanonicalDescription to be an explicit nil
func (o *EarningsTotal) SetCanonicalDescriptionNil() {
o.CanonicalDescription.Set(nil)
}
// UnsetCanonicalDescription ensures that no value is present for CanonicalDescription, not even an explicit nil
func (o *EarningsTotal) UnsetCanonicalDescription() {
o.CanonicalDescription.Unset()
}
// GetCurrentAmount returns the CurrentAmount field value if set, zero value otherwise (both if not set or set to explicit null).
func (o *EarningsTotal) GetCurrentAmount() float32 {
if o == nil || o.CurrentAmount.Get() == nil {
var ret float32
return ret
}
return *o.CurrentAmount.Get()
}
// GetCurrentAmountOk returns a tuple with the CurrentAmount field value if set, nil otherwise
// and a boolean to check if the value has been set.
// NOTE: If the value is an explicit nil, `nil, true` will be returned
func (o *EarningsTotal) GetCurrentAmountOk() (*float32, bool) {
if o == nil {
return nil, false
}
return o.CurrentAmount.Get(), o.CurrentAmount.IsSet()
}
// HasCurrentAmount returns a boolean if a field has been set.
func (o *EarningsTotal) HasCurrentAmount() bool {
if o != nil && o.CurrentAmount.IsSet() {
return true
}
return false
}
// SetCurrentAmount gets a reference to the given NullableFloat32 and assigns it to the CurrentAmount field.
func (o *EarningsTotal) SetCurrentAmount(v float32) {
o.CurrentAmount.Set(&v)
}
// SetCurrentAmountNil sets the value for CurrentAmount to be an explicit nil
func (o *EarningsTotal) SetCurrentAmountNil() {
o.CurrentAmount.Set(nil)
}
// UnsetCurrentAmount ensures that no value is present for CurrentAmount, not even an explicit nil
func (o *EarningsTotal) UnsetCurrentAmount() {
o.CurrentAmount.Unset()
}
// GetCurrentPay returns the CurrentPay field value if set, zero value otherwise.
func (o *EarningsTotal) GetCurrentPay() Pay {
if o == nil || o.CurrentPay == nil {
var ret Pay
return ret
}
return *o.CurrentPay
}
// GetCurrentPayOk returns a tuple with the CurrentPay field value if set, nil otherwise
// and a boolean to check if the value has been set.
func (o *EarningsTotal) GetCurrentPayOk() (*Pay, bool) {
if o == nil || o.CurrentPay == nil {
return nil, false
}
return o.CurrentPay, true
}
// HasCurrentPay returns a boolean if a field has been set.
func (o *EarningsTotal) HasCurrentPay() bool {
if o != nil && o.CurrentPay != nil {
return true
}
return false
}
// SetCurrentPay gets a reference to the given Pay and assigns it to the CurrentPay field.
func (o *EarningsTotal) SetCurrentPay(v Pay) {
o.CurrentPay = &v
}
// GetYtdPay returns the YtdPay field value if set, zero value otherwise.
func (o *EarningsTotal) GetYtdPay() Pay {
if o == nil || o.YtdPay == nil {
var ret Pay
return ret
}
return *o.YtdPay
}
// GetYtdPayOk returns a tuple with the YtdPay field value if set, nil otherwise
// and a boolean to check if the value has been set.
func (o *EarningsTotal) GetYtdPayOk() (*Pay, bool) {
if o == nil || o.YtdPay == nil {
return nil, false
}
return o.YtdPay, true
}
// HasYtdPay returns a boolean if a field has been set.
func (o *EarningsTotal) HasYtdPay() bool {
if o != nil && o.YtdPay != nil {
return true
}
return false
}
// SetYtdPay gets a reference to the given Pay and assigns it to the YtdPay field.
func (o *EarningsTotal) SetYtdPay(v Pay) {
o.YtdPay = &v
}
// GetHours returns the Hours field value if set, zero value otherwise (both if not set or set to explicit null).
func (o *EarningsTotal) GetHours() float32 {
if o == nil || o.Hours.Get() == nil {
var ret float32
return ret
}
return *o.Hours.Get()
}
// GetHoursOk returns a tuple with the Hours field value if set, nil otherwise
// and a boolean to check if the value has been set.
// NOTE: If the value is an explicit nil, `nil, true` will be returned
func (o *EarningsTotal) GetHoursOk() (*float32, bool) {
if o == nil {
return nil, false
}
return o.Hours.Get(), o.Hours.IsSet()
}
// HasHours returns a boolean if a field has been set.
func (o *EarningsTotal) HasHours() bool {
if o != nil && o.Hours.IsSet() {
return true
}
return false
}
// SetHours gets a reference to the given NullableFloat32 and assigns it to the Hours field.
func (o *EarningsTotal) SetHours(v float32) {
o.Hours.Set(&v)
}
// SetHoursNil sets the value for Hours to be an explicit nil
func (o *EarningsTotal) SetHoursNil() {
o.Hours.Set(nil)
}
// UnsetHours ensures that no value is present for Hours, not even an explicit nil
func (o *EarningsTotal) UnsetHours() {
o.Hours.Unset()
}
// GetIsoCurrencyCode returns the IsoCurrencyCode field value if set, zero value otherwise (both if not set or set to explicit null).
func (o *EarningsTotal) GetIsoCurrencyCode() string {
if o == nil || o.IsoCurrencyCode.Get() == nil {
var ret string
return ret
}
return *o.IsoCurrencyCode.Get()
}
// GetIsoCurrencyCodeOk returns a tuple with the IsoCurrencyCode field value if set, nil otherwise
// and a boolean to check if the value has been set.
// NOTE: If the value is an explicit nil, `nil, true` will be returned
func (o *EarningsTotal) GetIsoCurrencyCodeOk() (*string, bool) {
if o == nil {
return nil, false
}
return o.IsoCurrencyCode.Get(), o.IsoCurrencyCode.IsSet()
}
// HasIsoCurrencyCode returns a boolean if a field has been set.
func (o *EarningsTotal) HasIsoCurrencyCode() bool {
if o != nil && o.IsoCurrencyCode.IsSet() {
return true
}
return false
}
// SetIsoCurrencyCode gets a reference to the given NullableString and assigns it to the IsoCurrencyCode field.
func (o *EarningsTotal) SetIsoCurrencyCode(v string) {
o.IsoCurrencyCode.Set(&v)
}
// SetIsoCurrencyCodeNil sets the value for IsoCurrencyCode to be an explicit nil
func (o *EarningsTotal) SetIsoCurrencyCodeNil() {
o.IsoCurrencyCode.Set(nil)
}
// UnsetIsoCurrencyCode ensures that no value is present for IsoCurrencyCode, not even an explicit nil
func (o *EarningsTotal) UnsetIsoCurrencyCode() {
o.IsoCurrencyCode.Unset()
}
// GetUnofficialCurrencyCode returns the UnofficialCurrencyCode field value if set, zero value otherwise (both if not set or set to explicit null).
func (o *EarningsTotal) GetUnofficialCurrencyCode() string {
if o == nil || o.UnofficialCurrencyCode.Get() == nil {
var ret string
return ret
}
return *o.UnofficialCurrencyCode.Get()
}
// GetUnofficialCurrencyCodeOk returns a tuple with the UnofficialCurrencyCode field value if set, nil otherwise
// and a boolean to check if the value has been set.
// NOTE: If the value is an explicit nil, `nil, true` will be returned
func (o *EarningsTotal) GetUnofficialCurrencyCodeOk() (*string, bool) {
if o == nil {
return nil, false
}
return o.UnofficialCurrencyCode.Get(), o.UnofficialCurrencyCode.IsSet()
}
// HasUnofficialCurrencyCode returns a boolean if a field has been set.
func (o *EarningsTotal) HasUnofficialCurrencyCode() bool {
if o != nil && o.UnofficialCurrencyCode.IsSet() {
return true
}
return false
}
// SetUnofficialCurrencyCode gets a reference to the given NullableString and assigns it to the UnofficialCurrencyCode field.
func (o *EarningsTotal) SetUnofficialCurrencyCode(v string) {
o.UnofficialCurrencyCode.Set(&v)
}
// SetUnofficialCurrencyCodeNil sets the value for UnofficialCurrencyCode to be an explicit nil
func (o *EarningsTotal) SetUnofficialCurrencyCodeNil() {
o.UnofficialCurrencyCode.Set(nil)
}
// UnsetUnofficialCurrencyCode ensures that no value is present for UnofficialCurrencyCode, not even an explicit nil
func (o *EarningsTotal) UnsetUnofficialCurrencyCode() {
o.UnofficialCurrencyCode.Unset()
}
// GetYtdAmount returns the YtdAmount field value if set, zero value otherwise (both if not set or set to explicit null).
func (o *EarningsTotal) GetYtdAmount() float32 {
if o == nil || o.YtdAmount.Get() == nil {
var ret float32
return ret
}
return *o.YtdAmount.Get()
}
// GetYtdAmountOk returns a tuple with the YtdAmount field value if set, nil otherwise
// and a boolean to check if the value has been set.
// NOTE: If the value is an explicit nil, `nil, true` will be returned
func (o *EarningsTotal) GetYtdAmountOk() (*float32, bool) {
if o == nil {
return nil, false
}
return o.YtdAmount.Get(), o.YtdAmount.IsSet()
}
// HasYtdAmount returns a boolean if a field has been set.
func (o *EarningsTotal) HasYtdAmount() bool {
if o != nil && o.YtdAmount.IsSet() {
return true
}
return false
}
// SetYtdAmount gets a reference to the given NullableFloat32 and assigns it to the YtdAmount field.
func (o *EarningsTotal) SetYtdAmount(v float32) {
o.YtdAmount.Set(&v)
}
// SetYtdAmountNil sets the value for YtdAmount to be an explicit nil
func (o *EarningsTotal) SetYtdAmountNil() {
o.YtdAmount.Set(nil)
}
// UnsetYtdAmount ensures that no value is present for YtdAmount, not even an explicit nil
func (o *EarningsTotal) UnsetYtdAmount() {
o.YtdAmount.Unset()
}
func (o EarningsTotal) MarshalJSON() ([]byte, error) {
toSerialize := map[string]interface{}{}
if o.CanonicalDescription.IsSet() {
toSerialize["canonical_description"] = o.CanonicalDescription.Get()
}
if o.CurrentAmount.IsSet() {
toSerialize["current_amount"] = o.CurrentAmount.Get()
}
if o.CurrentPay != nil {
toSerialize["current_pay"] = o.CurrentPay
}
if o.YtdPay != nil {
toSerialize["ytd_pay"] = o.YtdPay
}
if o.Hours.IsSet() {
toSerialize["hours"] = o.Hours.Get()
}
if o.IsoCurrencyCode.IsSet() {
toSerialize["iso_currency_code"] = o.IsoCurrencyCode.Get()
}
if o.UnofficialCurrencyCode.IsSet() {
toSerialize["unofficial_currency_code"] = o.UnofficialCurrencyCode.Get()
}
if o.YtdAmount.IsSet() {
toSerialize["ytd_amount"] = o.YtdAmount.Get()
}
for key, value := range o.AdditionalProperties {
toSerialize[key] = value
}
return json.Marshal(toSerialize)
}
func (o *EarningsTotal) UnmarshalJSON(bytes []byte) (err error) {
varEarningsTotal := _EarningsTotal{}
if err = json.Unmarshal(bytes, &varEarningsTotal); err == nil {
*o = EarningsTotal(varEarningsTotal)
}
additionalProperties := make(map[string]interface{})
if err = json.Unmarshal(bytes, &additionalProperties); err == nil {
delete(additionalProperties, "canonical_description")
delete(additionalProperties, "current_amount")
delete(additionalProperties, "current_pay")
delete(additionalProperties, "ytd_pay")
delete(additionalProperties, "hours")
delete(additionalProperties, "iso_currency_code")
delete(additionalProperties, "unofficial_currency_code")
delete(additionalProperties, "ytd_amount")
o.AdditionalProperties = additionalProperties
}
return err
}
type NullableEarningsTotal struct {
value *EarningsTotal
isSet bool
}
func (v NullableEarningsTotal) Get() *EarningsTotal {
return v.value
}
func (v *NullableEarningsTotal) Set(val *EarningsTotal) {
v.value = val
v.isSet = true
}
func (v NullableEarningsTotal) IsSet() bool {
return v.isSet
}
func (v *NullableEarningsTotal) Unset() {
v.value = nil
v.isSet = false
}
func NewNullableEarningsTotal(val *EarningsTotal) *NullableEarningsTotal {
return &NullableEarningsTotal{value: val, isSet: true}
}
func (v NullableEarningsTotal) MarshalJSON() ([]byte, error) {
return json.Marshal(v.value)
}
func (v *NullableEarningsTotal) UnmarshalJSON(src []byte) error {
v.isSet = true
return json.Unmarshal(src, &v.value)
} | plaid/model_earnings_total.go | 0.816223 | 0.478651 | model_earnings_total.go | starcoder |
package main
import "fmt"
// Coord represents an integral coordinate
type Coord struct {
x int
y int
z int
}
func doDeltas() []Coord {
coords := make([]Coord, 0)
for x := -1; x <= 1; x++ {
for y := -1; y <= 1; y++ {
for z := -1; z <= 1; z++ {
if x == 0 && y == 0 && z == 0 {
continue
}
coords = append(coords, Coord{x, y, z})
}
}
}
return coords
}
var neighborDeltas = doDeltas()
const bits20 = 0xFFFFF
const bit21 = 0x100000
func bits21(n int) int64 {
if n < 0 {
return bit21 | int64(bits20&(-n))
}
return int64(bits20 & n)
}
func toInt(n int64) int {
if n&bit21 != 0 {
return int(-(n & bits20))
}
return int(n & bits20)
}
// Pack calculates a unique value (provided that no coordinate
// goes past 20 bits)
func (c Coord) Pack() int64 {
return bits21(c.z)<<42 | bits21(c.y)<<21 | bits21(c.x)
}
// Unpack takes apart a packed value and puts it back into the
// coordinate
func Unpack(n int64) Coord {
return Coord{
x: toInt(n),
y: toInt(n >> 21),
z: toInt(n >> 42),
}
}
// Board represents our "energy system"
type Board struct {
grid map[int64]bool
}
// Active returns the state of a single cell
func (b *Board) Active(c Coord) bool {
if active, ok := b.grid[c.Pack()]; ok {
return active
}
return false
}
// NeighborActive returns the state of a single cell
func (b *Board) NeighborActive(c Coord, d Coord) bool {
c.x += d.x
c.y += d.y
c.z += d.z
if active, ok := b.grid[c.Pack()]; ok {
return active
}
return false
}
// CountActive gets the total number of active cells on the board
func (b *Board) CountActive() int {
total := 0
for _, state := range b.grid {
if state {
total++
}
}
return total
}
// CountNeighbors returns the number of active neighbors for a grid coordinate.
func (b *Board) CountNeighbors(coord Coord) int {
total := 0
for _, neighbor := range neighborDeltas {
if b.NeighborActive(coord, neighbor) {
total++
}
}
return total
}
// Neighborhood returns a collection of all of the possible
// cells that need to be inspected for a given generation.
func (b *Board) Neighborhood() map[int64]Coord {
possibles := make(map[int64]Coord)
for pcoord := range b.grid {
for _, n := range neighborDeltas {
coord := Unpack(pcoord)
coord.x += n.x
coord.y += n.y
coord.z += n.z
possibles[coord.Pack()] = coord
}
}
return possibles
}
// Generation iterates a single generation into a new board.
func (b *Board) Generation() *Board {
nextBoard := NewBoard()
for pcoord, coord := range b.Neighborhood() {
neighbors := b.CountNeighbors(coord)
if b.Active(coord) {
if neighbors == 2 || neighbors == 3 {
nextBoard.grid[pcoord] = true
}
} else {
if neighbors == 3 {
nextBoard.grid[pcoord] = true
}
}
}
return nextBoard
}
func (b *Board) printActives() {
for pcoord := range b.grid {
fmt.Println(Unpack(pcoord))
}
}
// NewBoard builds a board
func NewBoard() *Board {
return &Board{
grid: make(map[int64]bool),
}
}
// ParseBoard builds a new board from an input text
func ParseBoard(lines []string) *Board {
board := NewBoard()
for row, line := range lines {
for col, ch := range line {
if ch == '#' {
coord := Coord{col, row, 0}
board.grid[coord.Pack()] = true
}
}
}
return board
} | day17/space3.go | 0.763924 | 0.445469 | space3.go | starcoder |
package battleships
import (
"errors"
"fmt"
"math/rand"
"regexp"
"strconv"
"time"
)
const (
// Rows defines number of rows of the game's board
Rows = 10
// Cols defines number of cols of the game's board
Cols = 10
inputRegex = "^[A-J](10|[1-9])$"
horizontalDirection = 0
verticalDirection = 1
// EmptySlot defines a field, that doesn't contain any ship and was hit hit so far
EmptySlot = '-'
// ShipSlot defines a field, that contains am undamaged ship
ShipSlot = 'S'
// HitShipSlot defines a field with a ship, that is already hit
HitShipSlot = 'X'
// MissedSlot defines a field without a ship, but that was shot at already
MissedSlot = 'O'
)
// PatternMismatch defines error used, when there is not match with the required pattern
type PatternMismatch struct {
input string
}
func (e PatternMismatch) Error() string {
return fmt.Sprintf("%v doesn't match the pattern %v", e.input, inputRegex)
}
// Board describes a game board used to store information about the current state of a game.
type Board [Rows][Cols]byte
// At is a convenient method used to access board field using the Position object. Returns byte at a specified location in the board
func (b *Board) At(p Position) byte {
return b[p.row][p.col]
}
// Set is a convenient method used to set a new value in the board indexing it with a Position object
func (b *Board) Set(p Position, val byte) {
b[p.row][p.col] = val
}
// Ship describes a single ship object used in the game
type Ship struct {
size uint8
health uint8
}
func (s *Ship) hit() bool {
s.health--
return s.health == 0
}
// NewShip creates a new ship with given size and full health
func NewShip(size uint8) Ship {
return Ship{
size: size,
health: size,
}
}
// Game defines an object used to initialize and start a new game
type Game struct {
Stats Statistics
shipsData map[Position]*Ship
board Board
initialized bool
}
// Statistics defines information about current state of the game
type Statistics struct {
ShotsFired int
InitialShips int
SunkShips int
}
// Position describes indexes used to access game's board
type Position struct {
row, col uint8
}
// Shot method allows to try to hit a ship at given position.
// First returned value is true, if a ship was hit. At the same time, if it was the last slot of a ship, true will be returned as second value
// Method returns error, if called before the game is iniatialized
func (g *Game) Shot(pos Position) (bool, bool, error) {
if !g.initialized {
return false, false, errors.New("Game not initialized")
}
g.Stats.ShotsFired++
if g.board.At(pos) == ShipSlot {
g.board.Set(pos, HitShipSlot)
s := g.shipsData[pos]
sunk := s.hit()
if sunk {
g.Stats.SunkShips++
}
return true, sunk, nil
} else if g.board.At(pos) == EmptySlot {
g.board.Set(pos, MissedSlot)
}
return false, false, nil
}
// FillBoard fills randomly the game's board with given ships.
// After that, the game is fully initialized and ready to be played
func (g *Game) FillBoard(ships []Ship) {
for i := 0; i < Rows; i++ {
for j := 0; j < Cols; j++ {
g.board[i][j] = EmptySlot
}
}
g.shipsData = make(map[Position]*Ship)
g.Stats.InitialShips = len(ships)
rand := rand.New(rand.NewSource(time.Now().Unix()))
for _, s := range ships {
placed := false
tries := 0
for !placed {
tries++
direction := rand.Intn(2)
maxRow := Rows
maxCol := Cols
if direction == horizontalDirection {
maxRow = Rows - int(s.size) + 1
} else {
maxCol = Cols - int(s.size) + 1
}
pos := randomPosition(rand, maxRow, maxCol)
if canPlaceShip(g, s, pos, direction) {
placeShip(g, s, pos, direction)
placed = true
}
if tries == 50 {
return
}
}
}
g.initialized = true
}
// Playable returns true, if there are still ships alive in the current game
func (g *Game) Playable() bool {
return g.initialized && g.Stats.SunkShips < g.Stats.InitialShips
}
// Board returns deep copy of a game's board. Parametr describes, if ships will be marked on the board or not
func (g *Game) Board(hiddenShips bool) *Board {
b := &Board{}
for i := 0; i < Rows; i++ {
for j := 0; j < Cols; j++ {
if hiddenShips && g.board[i][j] == ShipSlot {
b[i][j] = EmptySlot
} else {
b[i][j] = g.board[i][j]
}
}
}
return b
}
func randomPosition(rand *rand.Rand, maxR, maxC int) Position {
row := rand.Intn(maxR)
col := rand.Intn(maxC)
return Position{row: uint8(row), col: uint8(col)}
}
func canPlaceShip(g *Game, ship Ship, pos Position, direction int) bool {
for i := uint8(0); i < ship.size; i++ {
switch direction {
case horizontalDirection:
if !isValidPosition(g, pos.row, pos.col+i) {
return false
}
case verticalDirection:
if !isValidPosition(g, pos.row+i, pos.col) {
return false
}
}
}
return true
}
func isValidPosition(g *Game, row, col uint8) bool {
return isWithinBoard(row, col) && !isAnotherShipInNeighbourhood(g, row, col)
}
func isWithinBoard(row, col uint8) bool {
return row >= 0 && row < Rows && col >= 0 && col < Cols
}
func isAnotherShipInNeighbourhood(g *Game, row, col uint8) bool {
minR := max(0, int8(row-1))
maxR := min(Rows-1, int8(row+1))
minC := max(0, int8(col-1))
maxC := min(Cols-1, int8(col+1))
for i := minR; i <= maxR; i++ {
for j := minC; j <= maxC; j++ {
if g.board[i][j] == ShipSlot {
return true
}
}
}
return false
}
func min(x, y int8) int8 {
if x < y {
return x
}
return y
}
func max(x, y int8) int8 {
if x > y {
return x
}
return y
}
func placeShip(g *Game, ship Ship, pos Position, direction int) {
for i := uint8(0); i < ship.size; i++ {
switch direction {
case horizontalDirection:
g.addShip(&ship, Position{row: pos.row, col: pos.col + i})
case verticalDirection:
g.addShip(&ship, Position{row: pos.row + i, col: pos.col})
}
}
}
func (g *Game) addShip(ship *Ship, pos Position) {
g.board.Set(pos, ShipSlot)
g.shipsData[pos] = ship
}
// ConvertInputToPosition allows to convert text input in form [A-Z][1-10] to corresponding (row,column) position.
// Returns error if the input doesn't match required pattern
func ConvertInputToPosition(input string) (*Position, error) {
matched, err := regexp.MatchString(inputRegex, input)
if err != nil {
return nil, err
}
if !matched {
return nil, PatternMismatch{input}
}
letter := input[0]
number := input[1:]
row := letter - 'A'
col, _ := strconv.ParseUint(number, 10, 8)
return &Position{row: row, col: uint8(col - 1)}, nil
} | game.go | 0.743261 | 0.496887 | game.go | starcoder |
package pinapi_old
import (
_context "context"
_ioutil "io/ioutil"
_nethttp "net/http"
_neturl "net/url"
)
// Linger please
var (
_ _context.Context
)
// GetBetsApiService GetBetsApi service
type GetBetsApiService service
type apiBetsGetBetsByTypeV3Request struct {
ctx _context.Context
apiService *GetBetsApiService
betlist *string
betStatuses *[]string
fromDate *string
toDate *string
sortDir *string
pageSize *int32
fromRecord *int32
betids *[]int64
uniqueRequestIds *[]string
}
func (r apiBetsGetBetsByTypeV3Request) Betlist(betlist string) apiBetsGetBetsByTypeV3Request {
r.betlist = &betlist
return r
}
func (r apiBetsGetBetsByTypeV3Request) BetStatuses(betStatuses []string) apiBetsGetBetsByTypeV3Request {
r.betStatuses = &betStatuses
return r
}
func (r apiBetsGetBetsByTypeV3Request) FromDate(fromDate string) apiBetsGetBetsByTypeV3Request {
r.fromDate = &fromDate
return r
}
func (r apiBetsGetBetsByTypeV3Request) ToDate(toDate string) apiBetsGetBetsByTypeV3Request {
r.toDate = &toDate
return r
}
func (r apiBetsGetBetsByTypeV3Request) SortDir(sortDir string) apiBetsGetBetsByTypeV3Request {
r.sortDir = &sortDir
return r
}
func (r apiBetsGetBetsByTypeV3Request) PageSize(pageSize int32) apiBetsGetBetsByTypeV3Request {
r.pageSize = &pageSize
return r
}
func (r apiBetsGetBetsByTypeV3Request) FromRecord(fromRecord int32) apiBetsGetBetsByTypeV3Request {
r.fromRecord = &fromRecord
return r
}
func (r apiBetsGetBetsByTypeV3Request) Betids(betids []int64) apiBetsGetBetsByTypeV3Request {
r.betids = &betids
return r
}
func (r apiBetsGetBetsByTypeV3Request) UniqueRequestIds(uniqueRequestIds []string) apiBetsGetBetsByTypeV3Request {
r.uniqueRequestIds = &uniqueRequestIds
return r
}
/*
BetsGetBetsByTypeV3 Get Bets - v3
Returns bets.
### Get running bets by time range:
```
https://api.pinnacle.com/v3/bets?betlist=RUNNING&fromDate=2017-11-21T00:00:00Z&toDate=2017-11-29T00:00:00Z
```
Running bets are queried by *placedAt* date time
### Get settled bets by time range:
```
https://api.pinnacle.com/v3/bets?betlist=SETTLED&fromDate=2015-12-28T00:00:00Z&toDate=2015-12-29T00:00:00Z
```
Settled bets are queried by *settledAt* date time
https://api.pinnacle.com/v3/bets?betlist=SETTLED&fromDate=2017-11-20T00:00:00Z&toDate=2017-11-23T00:00:00Z
### Get settled cancelled bets by time range:
```
https://api.pinnacle.com/v3/bets?betList=SETTLED&fromDate=2018-03-01&toDate=2018-03-28&betStatuses=CANCELLED
```
### Get bets by bet ids:
```
https://api.pinnacle.com/v3/bets?betIds=775856112,775856113,775856114
```
### Get bets by uniqueRequestIds:
```
https://api.pinnacle.com/v3/bets?uniqueRequestIds=62335222-dae4-479a-8c05-46440ccdd3bb,42335222-dae4-479a-8c05-46440ccdd3bb
```
* @param ctx _context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return apiBetsGetBetsByTypeV3Request
*/
func (a *GetBetsApiService) BetsGetBetsByTypeV3(ctx _context.Context) apiBetsGetBetsByTypeV3Request {
return apiBetsGetBetsByTypeV3Request{
apiService: a,
ctx: ctx,
}
}
/*
Execute executes the request
@return GetBetsByTypeResponseV3
*/
func (r apiBetsGetBetsByTypeV3Request) Execute() (GetBetsByTypeResponseV3, *_nethttp.Response, error) {
var (
localVarHTTPMethod = _nethttp.MethodGet
localVarPostBody interface{}
localVarFormFileName string
localVarFileName string
localVarFileBytes []byte
localVarReturnValue GetBetsByTypeResponseV3
)
localBasePath, err := r.apiService.client.cfg.ServerURLWithContext(r.ctx, "GetBetsApiService.BetsGetBetsByTypeV3")
if err != nil {
return localVarReturnValue, nil, GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v3/bets"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := _neturl.Values{}
localVarFormParams := _neturl.Values{}
if r.betlist != nil {
localVarQueryParams.Add("betlist", parameterToString(*r.betlist, ""))
}
if r.betStatuses != nil {
localVarQueryParams.Add("betStatuses", parameterToString(*r.betStatuses, "csv"))
}
if r.fromDate != nil {
localVarQueryParams.Add("fromDate", parameterToString(*r.fromDate, ""))
}
if r.toDate != nil {
localVarQueryParams.Add("toDate", parameterToString(*r.toDate, ""))
}
if r.sortDir != nil {
localVarQueryParams.Add("sortDir", parameterToString(*r.sortDir, ""))
}
if r.pageSize != nil {
localVarQueryParams.Add("pageSize", parameterToString(*r.pageSize, ""))
}
if r.fromRecord != nil {
localVarQueryParams.Add("fromRecord", parameterToString(*r.fromRecord, ""))
}
if r.betids != nil {
localVarQueryParams.Add("betids", parameterToString(*r.betids, "csv"))
}
if r.uniqueRequestIds != nil {
localVarQueryParams.Add("uniqueRequestIds", parameterToString(*r.uniqueRequestIds, "csv"))
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := r.apiService.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := r.apiService.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
if localVarHTTPResponse.StatusCode == 200 {
var v GetBetsByTypeResponseV3
err = r.apiService.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
if localVarHTTPResponse.StatusCode == 400 {
var v ErrorResponse
err = r.apiService.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
if localVarHTTPResponse.StatusCode == 401 {
var v ErrorResponse
err = r.apiService.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
if localVarHTTPResponse.StatusCode == 403 {
var v ErrorResponse
err = r.apiService.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
if localVarHTTPResponse.StatusCode == 500 {
var v ErrorResponseWithErrorRef
err = r.apiService.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.model = v
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = r.apiService.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
} | pinapi_old/api_get_bets.go | 0.571408 | 0.540439 | api_get_bets.go | starcoder |
package vmath
import (
"math"
"github.com/go-gl/mathgl/mgl32"
)
type Frustum struct {
planes [6]fPlane
fovy, aspect, near, far float32
tang, nh, nw, fh, fw float32
}
type fPlane struct {
N, P mgl32.Vec3
D float32
}
func (f *fPlane) setPoints(v1, v2, v3 mgl32.Vec3) {
aux1 := v1.Sub(v2)
aux2 := v3.Sub(v2)
f.N = aux2.Cross(aux1)
f.N = safeNormalize(f.N)
f.P = v2
f.D = -(f.N.Dot(f.P))
}
func NewFrustum() *Frustum {
return &Frustum{}
}
func safeNormalize(v mgl32.Vec3) mgl32.Vec3 {
v = v.Normalize()
if math.IsInf(float64(v[0]), 0) || math.IsNaN(float64(v[0])) {
return mgl32.Vec3{}
}
return v
}
func (f *Frustum) SetPerspective(fovy, aspect, near, far float32) {
f.fovy = fovy
f.aspect = aspect
f.near = near
f.far = far
f.tang = float32(math.Tan(float64(fovy * 0.5)))
f.nh = near * f.tang
f.nw = f.nh * aspect
f.fh = far * f.tang
f.fw = f.fh * aspect
}
func (f *Frustum) SetCamera(p, l, u mgl32.Vec3) {
Z := p.Sub(l)
Z = safeNormalize(Z)
X := u.Cross(Z)
X = safeNormalize(X)
Y := Z.Cross(X)
nc := p.Sub(Z.Mul(f.near))
fc := p.Sub(Z.Mul(f.far))
ntl := nc.Add(Y.Mul(f.nh)).Sub(X.Mul(f.nw))
ntr := nc.Add(Y.Mul(f.nh)).Add(X.Mul(f.nw))
nbl := nc.Sub(Y.Mul(f.nh)).Sub(X.Mul(f.nw))
nbr := nc.Sub(Y.Mul(f.nh)).Add(X.Mul(f.nw))
ftl := fc.Add(Y.Mul(f.fh)).Sub(X.Mul(f.fw))
ftr := fc.Add(Y.Mul(f.fh)).Add(X.Mul(f.fw))
fbl := fc.Sub(Y.Mul(f.fh)).Sub(X.Mul(f.fw))
fbr := fc.Sub(Y.Mul(f.fh)).Add(X.Mul(f.fw))
const (
top = iota
bottom
left
right
nearP
farP
)
f.planes[top].setPoints(ntr, ntl, ftl)
f.planes[bottom].setPoints(nbl, nbr, fbr)
f.planes[left].setPoints(ntl, nbl, fbl)
f.planes[right].setPoints(nbr, ntr, fbr)
f.planes[nearP].setPoints(ntl, ntr, nbr)
f.planes[farP].setPoints(ftr, ftl, fbl)
}
func (f *Frustum) IsSphereInside(x, y, z, radius float32) bool {
p := mgl32.Vec3{x, y, z}
for i := range f.planes {
dist := f.planes[i].D + f.planes[i].N.Dot(p)
if dist < -radius {
return false
}
}
return true
}
func (f *Frustum) IsAABBInside(aabb AABB) bool {
for i := range f.planes {
v := aabb.Min
for j := 0; j < 3; j++ {
if f.planes[i].N[j] >= 0 {
v[j] = aabb.Max[j]
}
}
if f.planes[i].N.Dot(v)+f.planes[i].D < 0 {
return false
}
}
return true
} | type/vmath/frustum.go | 0.673621 | 0.409693 | frustum.go | starcoder |
package stdlib
import (
"fmt"
"reflect"
"github.com/krotik/ecal/parser"
)
/*
ECALFunctionAdapter models a bridge adapter between an ECAL function to a Go function.
*/
type ECALFunctionAdapter struct {
funcval reflect.Value
docstring string
}
/*
NewECALFunctionAdapter creates a new ECALFunctionAdapter.
*/
func NewECALFunctionAdapter(funcval reflect.Value, docstring string) *ECALFunctionAdapter {
return &ECALFunctionAdapter{funcval, docstring}
}
/*
Run executes this function.
*/
func (ea *ECALFunctionAdapter) Run(instanceID string, vs parser.Scope,
is map[string]interface{}, tid uint64, args []interface{}) (ret interface{}, err error) {
defer func() {
if r := recover(); r != nil {
err = fmt.Errorf("Error: %v", r)
}
}()
funcType := ea.funcval.Type()
// Build arguments
fargs := make([]reflect.Value, 0, len(args))
for i, arg := range args {
if i == funcType.NumIn() {
return nil, fmt.Errorf("Too many parameters - got %v expected %v",
len(args), funcType.NumIn())
}
expectedType := funcType.In(i)
// Try to convert into correct number types
if float64Arg, ok := arg.(float64); ok {
arg = ea.convertNumber(arg, float64Arg, expectedType)
}
givenType := reflect.TypeOf(arg)
// Check that the right types were given
if givenType != expectedType &&
!(expectedType.Kind() == reflect.Interface &&
givenType.Kind() == reflect.Interface &&
givenType.Implements(expectedType)) &&
expectedType != reflect.TypeOf([]interface{}{}) {
return nil, fmt.Errorf("Parameter %v should be of type %v but is of type %v",
i+1, expectedType, givenType)
}
fargs = append(fargs, reflect.ValueOf(arg))
}
// Call the function
vals := ea.funcval.Call(fargs)
// Convert result value
results := make([]interface{}, 0, len(vals))
for i, v := range vals {
res := v.Interface()
if i == len(vals)-1 {
// If the last item is an error then it is not part of the resutls
// (it will be wrapped into a proper runtime error later)
if funcType.Out(i) == reflect.TypeOf((*error)(nil)).Elem() {
if res != nil {
err = res.(error)
}
break
}
}
// Convert result if it is a primitive type
results = append(results, ea.convertResultNumber(res, v))
}
ret = results
// Return a single value if results contains only a single item
if len(results) == 1 {
ret = results[0]
}
return ret, err
}
/*
convertNumber converts number arguments into the right type.
*/
func (ea *ECALFunctionAdapter) convertNumber(arg interface{}, float64Arg float64, expectedType reflect.Type) interface{} {
switch expectedType.Kind() {
case reflect.Int:
arg = int(float64Arg)
case reflect.Int8:
arg = int8(float64Arg)
case reflect.Int16:
arg = int16(float64Arg)
case reflect.Int32:
arg = int32(float64Arg)
case reflect.Int64:
arg = int64(float64Arg)
case reflect.Uint:
arg = uint(float64Arg)
case reflect.Uint8:
arg = uint8(float64Arg)
case reflect.Uint16:
arg = uint16(float64Arg)
case reflect.Uint32:
arg = uint32(float64Arg)
case reflect.Uint64:
arg = uint64(float64Arg)
case reflect.Uintptr:
arg = uintptr(float64Arg)
case reflect.Float32:
arg = float32(float64Arg)
}
return arg
}
/*
convertResultNumber converts result numbers into the right type.
*/
func (ea *ECALFunctionAdapter) convertResultNumber(res interface{}, v reflect.Value) interface{} {
switch v.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
res = float64(v.Int())
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
res = float64(v.Uint())
case reflect.Float32, reflect.Float64:
res = v.Float()
}
return res
}
/*
DocString returns the docstring of the wrapped function.
*/
func (ea *ECALFunctionAdapter) DocString() (string, error) {
return ea.docstring, nil
} | stdlib/adapter.go | 0.671794 | 0.426083 | adapter.go | starcoder |
package cache
import (
"sync"
sharev1alpha1 "github.com/openshift/api/sharedresource/v1alpha1"
"github.com/openshift/csi-driver-shared-resource/pkg/client"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/klog/v2"
)
/*
Some old fashioned comments that describe what we are doing in this golang file.
First, some notes on cardinality:
- 1 share at the moment only references 1 configmap or 1 secret
- 1 share can be used by many pods, and in particular, many CSI Driver volume mounts across those pods. This driver
end of the day manages those CSI volumes, with of course the associated Pod and its various fields key metadata
Second, events. As the AddSharedConfigMap, UpdateSharedConfigMap, or DelSharedConfigMap names imply, those methods are called when the controller
processes Add/Update/Delete events for SharedResource instances. To date, the Update path is a superset of the Add path. Or
in other words, the UpdateSharedConfigMap ultimately calls the AddSharedConfigMap function.
Third, our data structure of note: the golang sync.Map. The implementation provides some key features for us:
- the implicit synchronization as we get, store, delete specific entries, or range over a set of entries
- with range in particular, you supply a function that is called as each key/value pair is inspected. That function
receives the key and value, and as golang function parameters work, that function can be seeded with data specific to
where it was created, vs. its use here. This allows us to abstract the functional details specific our CSI volume
implementation, and the events it receives from the kubelet as part of Pod creation, from the code here that deals with
handling share events from the controller
- so the CSI driver side of our solution here "registers callbacks". Those "callbacks" are code on its side that it wants
executed when a share creation, update. or deletion event occurs.
- much like you'll see with data grid products, the "maps" are effectively in memory database tables, albeit with simple
indexing and querying (which is implemented by how we create map subsets "seed" the Range call).
Fourth, a couple of notes on permissions and shareConfigMaps
- The SAR execution occurs on 2 events:
- 1) the pod creation / request to mount the CSI volume event from the kubelet
- 2) when a share update event occurs, which can be when the share is actually updated, or on the relist; the relist
variety is how we currently verify that a given pod is *STILL* allowed to access a given share if nothing else has changed.
*/
var (
// sharesUpdateCallbacks/shareSecretsUpdateCallbacks have a key of the CSI volume ID and a value of the function to be called when a given
// share is to updated, assuming the driver has mounted a share CSI volume in a pod somewhere. Otherwise,
// this map is empty and share updates result in a no-op. This map is used both when we get an event for a given
// share or a series of events as a result of a relist from the controller.
shareConfigMapsUpdateCallbacks = sync.Map{}
shareSecretsUpdateCallbacks = sync.Map{}
// same thing as shareConfigMapsUpdateCallbacks/shareSecretsUpdateCallbacks, but deletion of the objects, and of course the controller relist does not
// come into play here.
shareConfigMapsDeleteCallbacks = sync.Map{}
shareSecretsDeleteCallbacks = sync.Map{}
)
// AddSharedConfigMap adds the SharedConfigMap and its referenced config map to our various tracking maps
func AddSharedConfigMap(share *sharev1alpha1.SharedConfigMap) {
br := share.Spec.ConfigMapRef
key := BuildKey(br.Namespace, br.Name)
klog.V(4).Infof("AddSharedConfigMap share %s key %s", share.Name, key)
cm := client.GetConfigMap(br.Namespace, br.Name)
if cm != nil {
// so this line build a map with a single entry, the share from this event, and then
// applies the function(s) supplied by the CSI volume code in order to make changes based
// on this event
shareConfigMapsUpdateCallbacks.Range(buildRanger(buildCallbackMap(share.Name, share)))
}
}
// AddSharedSecret adds the SharedSecret and its referenced secret to our various tracking maps
func AddSharedSecret(share *sharev1alpha1.SharedSecret) {
br := share.Spec.SecretRef
key := BuildKey(br.Namespace, br.Name)
klog.V(4).Infof("AddSharedSecret key %s", key)
s := client.GetSecret(br.Namespace, br.Name)
if s != nil {
// so this line build a map with a single entry, the share from this event, and then
// applies the function(s) supplied by the CSI volume code in order to make changes based
// on this event
shareSecretsUpdateCallbacks.Range(buildRanger(buildCallbackMap(share.Name, share)))
}
}
// UpdateSharedConfigMap updates the SharedConfigMap in our various tracking maps and if need be calls
// the registered callbacks to update the content on any volumes using the SharedConfigMap
func UpdateSharedConfigMap(share *sharev1alpha1.SharedConfigMap) {
klog.V(4).Infof("UpdateSharedConfigMap key %s", share.Name)
AddSharedConfigMap(share)
}
// UpdateSharedSecret updates the SharedSecret in our various tracking maps and if need be calls
// the registered callbacks to update the content on any volumes using the SharedSecret
func UpdateSharedSecret(share *sharev1alpha1.SharedSecret) {
klog.V(4).Infof("UpdateSharedSecret key %s", share.Name)
AddSharedSecret(share)
}
func NamespacesWithSharedConfigMaps() map[string]struct{} {
namespacesMap := map[string]struct{}{}
list, err := client.GetListers().SharedConfigMaps.List(labels.Everything())
if err == nil {
for _, scm := range list {
namespacesMap[scm.Spec.ConfigMapRef.Namespace] = struct{}{}
}
}
return namespacesMap
}
func NamespacesWithSharedSecrets() map[string]struct{} {
namespacesMap := map[string]struct{}{}
list, err := client.GetListers().SharedSecrets.List(labels.Everything())
if err == nil {
for _, ss := range list {
namespacesMap[ss.Spec.SecretRef.Namespace] = struct{}{}
}
}
return namespacesMap
}
// DelSharedConfigMap removes the SharedConfigMap from our various tracking maps and calls the registered callbacks
// to delete the config map content from any volumes using the SharedConfigMap
func DelSharedConfigMap(share *sharev1alpha1.SharedConfigMap) {
br := share.Spec.ConfigMapRef
key := BuildKey(br.Namespace, br.Name)
klog.V(4).Infof("DelSharedConfigMap key %s", key)
shareConfigMapsDeleteCallbacks.Range(buildRanger(buildCallbackMap(share.Name, share)))
}
// DelSharedSecret removes the SharedSecret from our various tracking maps and calls the registered callbacks
// to delete the secret content from any volumes using the SharedSecret
func DelSharedSecret(share *sharev1alpha1.SharedSecret) {
br := share.Spec.SecretRef
key := BuildKey(br.Namespace, br.Name)
klog.V(4).Infof("DelSharedSecret key %s", key)
shareSecretsDeleteCallbacks.Range(buildRanger(buildCallbackMap(share.Name, share)))
}
// RegisterSharedConfigMapUpdateCallback will be called as part of the kubelet sending a mount CSI volume request for a pod;
// then on controller update events for a SharedConfigMap, then function registered here will be called to possibly change
// storage
func RegisterSharedConfigMapUpdateCallback(volID, shareID string, f func(key, value interface{}) bool) {
shareConfigMapsUpdateCallbacks.Store(volID, f)
// cycle through the shareConfigMaps to find the one correlates to this volID's CSI volume mount request; the function
// provided then completes the actual storage of the data in the pod
share := client.GetSharedConfigMap(shareID)
if share != nil {
f(share.Name, share)
} else {
klog.Warningf("not found issue using sharedconfigmaps get %s for volume %s", shareID, volID)
}
}
// RegisterSharedSecretUpdateCallback will be called as part of the kubelet sending a mount CSI volume request for a pod;
// then on controller update events for a SharedSecret, then function registered here will be called to possibly change
// storage
func RegisterSharedSecretUpdateCallback(volID, shareID string, f func(key, value interface{}) bool) {
shareSecretsUpdateCallbacks.Store(volID, f)
share := client.GetSharedSecret(shareID)
if share != nil {
f(share.Name, share)
} else {
klog.Warningf("not found issue using sharedsecrets get %s for volume %s", shareID, volID)
}
}
// UnregisterSharedConfigMapUpdateCallback will be called as part of the kubelet sending a delete CSI volume request for a pod
// that is going away, and we remove the corresponding function for that volID
func UnregisterSharedConfigMapUpdateCallback(volID string) {
configmapUpsertCallbacks.Delete(volID)
}
// UnregsiterSharedSecretsUpdateCallback will be called as part of the kubelet sending a delete CSI volume request for a pod
// that is going away, and we remove the corresponding function for that volID
func UnregsiterSharedSecretsUpdateCallback(volID string) {
secretUpsertCallbacks.Delete(volID)
}
// RegisterSharedConfigMapDeleteCallback will be called as part of the kubelet sending a mount CSI volume request for a pod;
// it records the CSI driver function to be called when a share is deleted, so that the CSI
// driver can remove any storage mounted in the pod for the given SharedConfigMap
func RegisterSharedConfigMapDeleteCallback(volID string, f func(key, value interface{}) bool) {
shareConfigMapsDeleteCallbacks.Store(volID, f)
}
// RegisteredSharedSecretDeleteCallback will be called as part of the kubelet sending a mount CSI volume request for a pod;
// it records the CSI driver function to be called when a share is deleted, so that the CSI
// driver can remove any storage mounted in the pod for the given SharedSecret
func RegisteredSharedSecretDeleteCallback(volID string, f func(key, value interface{}) bool) {
shareSecretsDeleteCallbacks.Store(volID, f)
}
// UnregisterSharedConfigMapDeleteCallback will be called as part of the kubelet sending a delete CSI volume request for a pod
// that is going away, and we remove the corresponding function for that volID
func UnregisterSharedConfigMapDeleteCallback(volID string) {
shareConfigMapsDeleteCallbacks.Delete(volID)
}
// UnregisterSharedSecretDeleteCallback will be called as part of the kubelet sending a delete CSI volume request for a pod
// that is going away, and we remove the corresponding function for that volID
func UnregisterSharedSecretDeleteCallback(volID string) {
shareSecretsDeleteCallbacks.Delete(volID)
} | pkg/cache/shares.go | 0.601477 | 0.453867 | shares.go | starcoder |
package adt
import "container/heap"
// PriorityQueue represents an ordered collection of elements that can be
// accessed in a priority-first manner. Elements with a higher priority are
// retrieved before elements with a lower priority. Priority is represented in
// a lower-value order; the closer a priority is to zero, the higher priority
// it receives.
type PriorityQueue struct {
elements *pqueue
indexes map[interface{}]int
}
// NewPriorityQueue returns a priority queue of size n.
func NewPriorityQueue(n int) *PriorityQueue {
elements := make(pqueue, n)
pq := &PriorityQueue{
elements: &elements,
indexes: make(map[interface{}]int),
}
heap.Init(pq.elements)
return pq
}
// Push inserts a new element e with value v and priority p to the queue.
func (pq *PriorityQueue) Push(v interface{}, p float64) {
e := &element{
value: v,
priority: p,
}
pq.indexes[v] = len(*pq.elements)
heap.Push(pq.elements, e)
}
// Pop removes the element with the highest priority and returns its value.
func (pq *PriorityQueue) Pop() interface{} {
if len(*pq.elements) == 0 {
return nil
}
elem := heap.Pop(pq.elements).(*element)
delete(pq.indexes, elem.value)
return elem.value
}
// Prioritize adjusts the priority of element v to priority p and adjusts the
// queue order.
func (pq *PriorityQueue) Prioritize(v interface{}, p float64) {
i := pq.indexes[v]
e := pq.elements.Elem(i)
e.priority = p
heap.Fix(pq.elements, i)
}
// Len returns the number of elements in the queue.
func (pq PriorityQueue) Len() int {
return len(*pq.elements)
}
type element struct {
value interface{}
priority float64
}
type pqueue []*element
func (pq pqueue) Len() int {
return len(pq)
}
func (pq pqueue) Less(i, j int) bool {
return pq[i].priority < pq[j].priority
}
func (pq pqueue) Swap(i, j int) {
pq[i], pq[j] = pq[j], pq[i]
}
func (pq *pqueue) Push(x interface{}) {
elem := x.(*element)
*pq = append(*pq, elem)
}
func (pq *pqueue) Pop() interface{} {
old := *pq
n := len(old)
elem := old[n-1]
old[n-1] = nil // avoid memory leak
*pq = old[0 : n-1]
return elem
}
func (pq pqueue) Elem(i int) *element {
return pq[i]
} | priority_queue.go | 0.81841 | 0.483283 | priority_queue.go | starcoder |
package trank
import (
"math"
"sort"
"github.com/algao1/basically"
)
// A WGraph is an undirected graph, with nodes representing words within
// a document. Edges represent the connection between words.
type WGraph struct {
Nodes map[string]float64
Edges map[string]map[string]int
}
// KWTextRank implements the Highlighter interface.
type KWTextRank struct {
Graph *WGraph
Tokens []*basically.Token
}
var _ basically.Highlighter = (*KWTextRank)(nil)
// Initialize initializes the underlying WGraph by inserting nodes and edges.
func (kwtr *KWTextRank) Initialize(tokens []*basically.Token,
filter basically.TokenFilter, window int) {
// Instantiate a new WGraph.
kwtr.Graph = &WGraph{Nodes: make(map[string]float64), Edges: make(map[string]map[string]int)}
kwtr.Tokens = tokens
for i := 0; i < len(tokens); i++ {
// Insert tokens as nodes if they pass through filter.
if filter(tokens[i]) {
text := tokens[i].Text
kwtr.Graph.Nodes[text] = 1.0
if _, ok := kwtr.Graph.Edges[text]; !ok {
kwtr.Graph.Edges[text] = make(map[string]int)
}
// Backtracks to add edges.
if i >= window {
kwtr.lookBack(tokens[i-window:i+1], filter)
}
}
}
}
// lookBack adds weighted edges to the WGraph if any of the previous tokens within a window
// satisfies the filter.
func (kwtr *KWTextRank) lookBack(tokens []*basically.Token, filter basically.TokenFilter) {
end := len(tokens) - 1
t1 := tokens[end]
for idx, t2 := range tokens[:end] {
if filter(t2) {
lt1, lt2 := t1.Text, t2.Text
// The weight of the edge increases the closer the words are.
kwtr.Graph.Edges[lt1][lt2] = end / (end - idx)
kwtr.Graph.Edges[lt2][lt1] = end / (end - idx)
}
}
}
// Rank applies the TextRank algorithm on the WGraph for some specified iterations.
func (kwtr *KWTextRank) Rank(iters int) {
outWeights := kwtr.outWeights()
for iter := 0; iter < iters; iter++ {
for to, edges := range kwtr.Graph.Edges {
var sum float64
for from := range edges {
// Ignore outWeights if 0 to avoid Inf or NaN.
if outWeights[to] == 0 {
continue
}
sum += float64(kwtr.Graph.Edges[to][from]) / outWeights[from] * kwtr.Graph.Nodes[from]
}
kwtr.Graph.Nodes[to] = 0.15 + 0.85*sum
}
}
}
// outWeights calculates the weights of outgoing edges.
func (kwtr *KWTextRank) outWeights() map[string]float64 {
n := len(kwtr.Graph.Nodes)
weights := make(map[string]float64, n)
// Iterate over the edge sets.
for t, e := range kwtr.Graph.Edges {
var sum float64
// Iterate over the edges/weights in the edge set.
for _, w := range e {
sum += float64(w)
}
weights[t] = sum
}
return weights
}
// Highlight sorts the keywords by weight, and returns the most significant keywords.
// Can optionally be specified to merge keywords together to get multi-word extraction.
func (kwtr *KWTextRank) Highlight(words int, merge bool) ([]*basically.Keyword, error) {
// If the number of keywords is negative, or greater than the number of vertices,
// automatically set to be 1/3 of the nodes.
if words < 0 || words > len(kwtr.Graph.Nodes) {
words = len(kwtr.Graph.Nodes) / 3
}
// Create a list of keywords.
kwords := make([]*basically.Keyword, 0, len(kwtr.Graph.Nodes))
for kw, w := range kwtr.Graph.Nodes {
kwords = append(kwords, &basically.Keyword{Word: kw, Weight: w})
}
sort.Slice(kwords, func(i, j int) bool { return kwords[i].Weight > kwords[j].Weight })
kwords = kwords[:words]
// Form multi-word keywords if specified.
if merge {
// Create a dictionary to avoid duplicates.
kwdict := make(map[string]*basically.Keyword)
for _, kw := range kwords {
kwdict[kw.Word] = kw
}
// Procedure is similar to maximal-munch.
queue := make([]*basically.Keyword, 0)
for _, tok := range kwtr.Tokens {
if kw, ok := kwdict[tok.Text]; ok {
queue = append(queue, kw)
continue
} else if len(queue) > 1 {
// Append the new keyword if non-duplicate.
nKW := mergeKW(queue)
if _, ok := kwdict[nKW.Word]; !ok {
kwdict[nKW.Word] = nKW
kwords = append(kwords, nKW)
}
}
queue = nil
}
}
sort.Slice(kwords, func(i, j int) bool { return kwords[i].Weight > kwords[j].Weight })
return kwords[:words], nil
}
// mergeKW merges a slice of keywords to form one keyword.
func mergeKW(kws []*basically.Keyword) *basically.Keyword {
word := ""
max := 0.0
min := 0.01
sum := 0.0
for idx, kw := range kws {
if idx > 0 {
word += " "
}
word += kw.Word
max = math.Max(max, kw.Weight)
min = math.Min(min, kw.Weight)
sum += kw.Weight
}
weight := max - math.Abs(math.Log10(max))
return &basically.Keyword{Word: word, Weight: weight}
} | trank/trank.go | 0.784113 | 0.472866 | trank.go | starcoder |
package birch
import (
"fmt"
"io"
"math"
"time"
"github.com/tychoish/birch/jsonx"
)
// DC is a convenience variable provided for access to the DocumentConstructor methods.
var DC DocumentConstructor
// DocumentConstructor is used as a namespace for document constructor functions.
type DocumentConstructor struct{}
// New returns an empty document.
func (DocumentConstructor) New() *Document { return DC.Make(0) }
// Make returns a document with the underlying storage
// allocated as specified. Provides some efficiency when building
// larger documents iteratively.
func (DocumentConstructor) Make(n int) *Document {
return &Document{
elems: make([]*Element, 0, n),
index: make([]uint32, 0, n),
}
}
// Elements returns a document initialized with the elements passed as
// arguments.
func (DocumentConstructor) Elements(elems ...*Element) *Document {
return DC.Make(len(elems)).Append(elems...)
}
// ElementsOmitEmpty crates a document with all non-empty values.
func (DocumentConstructor) ElementsOmitEmpty(elems ...*Element) *Document {
return DC.New().AppendOmitEmpty(elems...)
}
// Reader constructs a document from a bson reader, which is a wrapper
// around a byte slice representation of a bson document. Reader
// panics if there is a problem reading the document.
func (DocumentConstructor) Reader(r Reader) *Document {
doc, err := DC.ReaderErr(r)
if err != nil {
panic(err)
}
return doc
}
// ReaderErr constructs a document from a bson reader, which is a wrapper
// around a byte slice representation of a bson document. Reader
// returns an error if there is a problem reading the document.
func (DocumentConstructor) ReaderErr(r Reader) (*Document, error) {
return ReadDocument(r)
}
// ReadFrom builds a document reading a bytes sequence from an
// io.Reader, panicing if there's a problem reading from the reader.
func (DocumentConstructor) ReadFrom(in io.Reader) *Document {
doc, err := DC.ReadFromErr(in)
if err == io.EOF {
return nil
}
if err != nil {
panic(err)
}
return doc
}
// ReadFromErr builds a document reading a bytes sequence from an
// io.Reader, returning an error if there's a problem reading from the
// reader.
func (DocumentConstructor) ReadFromErr(in io.Reader) (*Document, error) {
doc := DC.New()
_, err := doc.ReadFrom(in)
if err == io.EOF {
return nil, err
}
if err != nil {
return nil, err
}
return doc, nil
}
func (DocumentConstructor) Marshaler(in Marshaler) *Document {
doc, err := DC.MarshalerErr(in)
if err != nil {
panic(err)
}
return doc
}
func (DocumentConstructor) MarshalerErr(in Marshaler) (*Document, error) {
data, err := in.MarshalBSON()
if err != nil {
return nil, err
}
return DC.ReaderErr(data)
}
func (DocumentConstructor) MapString(in map[string]string) *Document {
elems := make([]*Element, 0, len(in))
for k, v := range in {
elems = append(elems, EC.String(k, v))
}
return DC.Elements(elems...)
}
func (DocumentConstructor) MapJSONX(in map[string]*jsonx.Document) *Document {
elems := make([]*Element, 0, len(in))
for k, v := range in {
elems = append(elems, EC.JSONX(k, v))
}
return DC.Elements(elems...)
}
func (DocumentConstructor) MapInterface(in map[string]interface{}) *Document {
elems := make([]*Element, 0, len(in))
for k, v := range in {
elems = append(elems, EC.Interface(k, v))
}
return DC.Elements(elems...)
}
func (DocumentConstructor) MapInterfaceErr(in map[string]interface{}) (*Document, error) {
elems := make([]*Element, 0, len(in))
for k, v := range in {
elem, err := EC.InterfaceErr(k, v)
if err != nil {
return nil, err
}
if elem != nil {
elems = append(elems, elem)
}
}
return DC.Elements(elems...), nil
}
func (DocumentConstructor) MapInt64(in map[string]int64) *Document {
elems := make([]*Element, 0, len(in))
for k, v := range in {
elems = append(elems, EC.Int64(k, v))
}
return DC.Elements(elems...)
}
func (DocumentConstructor) MapInt32(in map[string]int32) *Document {
elems := make([]*Element, 0, len(in))
for k, v := range in {
elems = append(elems, EC.Int32(k, v))
}
return DC.Elements(elems...)
}
func (DocumentConstructor) MapFloat64(in map[string]float64) *Document {
elems := make([]*Element, 0, len(in))
for k, v := range in {
elems = append(elems, EC.Double(k, v))
}
return DC.Elements(elems...)
}
func (DocumentConstructor) MapFloat32(in map[string]float32) *Document {
elems := make([]*Element, 0, len(in))
for k, v := range in {
elems = append(elems, EC.Double(k, float64(v)))
}
return DC.Elements(elems...)
}
func (DocumentConstructor) MapInt(in map[string]int) *Document {
elems := make([]*Element, 0, len(in))
for k, v := range in {
elems = append(elems, EC.Int(k, v))
}
return DC.Elements(elems...)
}
func (DocumentConstructor) MapTime(in map[string]time.Time) *Document {
elems := make([]*Element, 0, len(in))
for k, v := range in {
elems = append(elems, EC.Time(k, v))
}
return DC.Elements(elems...)
}
func (DocumentConstructor) MapDuration(in map[string]time.Duration) *Document {
elems := make([]*Element, 0, len(in))
for k, v := range in {
elems = append(elems, EC.Duration(k, v))
}
return DC.Elements(elems...)
}
func (DocumentConstructor) MapMarshaler(in map[string]Marshaler) *Document {
elems := make([]*Element, 0, len(in))
for k, v := range in {
elems = append(elems, EC.Marshaler(k, v))
}
return DC.Elements(elems...)
}
func (DocumentConstructor) MapMarshalerErr(in map[string]Marshaler) (*Document, error) {
elems := make([]*Element, 0, len(in))
for k, v := range in {
elem, err := EC.MarshalerErr(k, v)
if err != nil {
return nil, err
}
if elem != nil {
elems = append(elems, elem)
}
}
return DC.Elements(elems...), nil
}
func (DocumentConstructor) MapSliceMarshaler(in map[string][]Marshaler) *Document {
elems := make([]*Element, 0, len(in))
for k, v := range in {
elems = append(elems, EC.SliceMarshaler(k, v))
}
return DC.Elements(elems...)
}
func (DocumentConstructor) MapSliceMarshalerErr(in map[string][]Marshaler) (*Document, error) {
elems := make([]*Element, 0, len(in))
for k, v := range in {
elem, err := EC.SliceMarshalerErr(k, v)
if err != nil {
return nil, err
}
if elem != nil {
elems = append(elems, elem)
}
}
return DC.Elements(elems...), nil
}
func (DocumentConstructor) MapDocumentMarshaler(in map[string]DocumentMarshaler) *Document {
elems := make([]*Element, 0, len(in))
for k, v := range in {
elems = append(elems, EC.DocumentMarshaler(k, v))
}
return DC.Elements(elems...)
}
func (DocumentConstructor) MapSliceJSONX(in map[string][]*jsonx.Document) *Document {
elems := make([]*Element, 0, len(in))
for k, v := range in {
elems = append(elems, EC.SliceJSONX(k, v))
}
return DC.Elements(elems...)
}
func (DocumentConstructor) MapDocumentMarshalerErr(in map[string]DocumentMarshaler) (*Document, error) {
elems := make([]*Element, 0, len(in))
for k, v := range in {
elem, err := EC.DocumentMarshalerErr(k, v)
if err != nil {
return nil, err
}
if elem != nil {
elems = append(elems, elem)
}
}
return DC.Elements(elems...), nil
}
func (DocumentConstructor) MapSliceDocumentMarshaler(in map[string][]DocumentMarshaler) *Document {
elems := make([]*Element, 0, len(in))
for k, v := range in {
elems = append(elems, EC.SliceDocumentMarshaler(k, v))
}
return DC.Elements(elems...)
}
func (DocumentConstructor) MapSliceDocumentMarshalerErr(in map[string][]DocumentMarshaler) (*Document, error) {
elems := make([]*Element, 0, len(in))
for k, v := range in {
elem, err := EC.SliceDocumentMarshalerErr(k, v)
if err != nil {
return nil, err
}
if elem != nil {
elems = append(elems, elem)
}
}
return DC.Elements(elems...), nil
}
func (DocumentConstructor) MapSliceString(in map[string][]string) *Document {
elems := make([]*Element, 0, len(in))
for k, v := range in {
elems = append(elems, EC.SliceString(k, v))
}
return DC.Elements(elems...)
}
func (DocumentConstructor) MapSliceInterface(in map[string][]interface{}) *Document {
elems := make([]*Element, 0, len(in))
for k, v := range in {
elems = append(elems, EC.SliceInterface(k, v))
}
return DC.Elements(elems...)
}
func (DocumentConstructor) MapSliceInterfaceErr(in map[string][]interface{}) (*Document, error) {
elems := make([]*Element, 0, len(in))
for k, v := range in {
elem, err := EC.SliceInterfaceErr(k, v)
if err != nil {
return nil, err
}
if elem != nil {
elems = append(elems, elem)
}
}
return DC.Elements(elems...), nil
}
func (DocumentConstructor) MapSliceInt64(in map[string][]int64) *Document {
elems := make([]*Element, 0, len(in))
for k, v := range in {
elems = append(elems, EC.SliceInt64(k, v))
}
return DC.Elements(elems...)
}
func (DocumentConstructor) MapSliceInt32(in map[string][]int32) *Document {
elems := make([]*Element, 0, len(in))
for k, v := range in {
elems = append(elems, EC.SliceInt32(k, v))
}
return DC.Elements(elems...)
}
func (DocumentConstructor) MapSliceFloat64(in map[string][]float64) *Document {
elems := make([]*Element, 0, len(in))
for k, v := range in {
elems = append(elems, EC.SliceFloat64(k, v))
}
return DC.Elements(elems...)
}
func (DocumentConstructor) MapSliceFloat32(in map[string][]float32) *Document {
elems := make([]*Element, 0, len(in))
for k, v := range in {
elems = append(elems, EC.SliceFloat32(k, v))
}
return DC.Elements(elems...)
}
func (DocumentConstructor) MapSliceInt(in map[string][]int) *Document {
elems := make([]*Element, 0, len(in))
for k, v := range in {
elems = append(elems, EC.SliceInt(k, v))
}
return DC.Elements(elems...)
}
func (DocumentConstructor) MapSliceDuration(in map[string][]time.Duration) *Document {
elems := make([]*Element, 0, len(in))
for k, v := range in {
elems = append(elems, EC.SliceDuration(k, v))
}
return DC.Elements(elems...)
}
func (DocumentConstructor) MapSliceTime(in map[string][]time.Time) *Document {
elems := make([]*Element, 0, len(in))
for k, v := range in {
elems = append(elems, EC.SliceTime(k, v))
}
return DC.Elements(elems...)
}
func (DocumentConstructor) Interface(value interface{}) *Document {
var (
doc *Document
err error
)
switch t := value.(type) {
case map[string]string:
doc = DC.MapString(t)
case map[string][]string:
doc = DC.MapSliceString(t)
case map[string]interface{}:
doc = DC.MapInterface(t)
case map[string][]interface{}:
doc = DC.MapSliceInterface(t)
case map[string]DocumentMarshaler:
doc, err = DC.MapDocumentMarshalerErr(t)
case map[string][]DocumentMarshaler:
doc, err = DC.MapSliceDocumentMarshalerErr(t)
case map[string]Marshaler:
doc, err = DC.MapMarshalerErr(t)
case map[string][]Marshaler:
doc, err = DC.MapSliceMarshalerErr(t)
case map[string]int64:
doc = DC.MapInt64(t)
case map[string][]int64:
doc = DC.MapSliceInt64(t)
case map[string]int32:
doc = DC.MapInt32(t)
case map[string][]int32:
doc = DC.MapSliceInt32(t)
case map[string]int:
doc = DC.MapInt(t)
case map[string][]int:
doc = DC.MapSliceInt(t)
case map[string]time.Time:
doc = DC.MapTime(t)
case map[string][]time.Time:
doc = DC.MapSliceTime(t)
case map[string]time.Duration:
doc = DC.MapDuration(t)
case map[string][]time.Duration:
doc = DC.MapSliceDuration(t)
case map[interface{}]interface{}:
elems := make([]*Element, 0, len(t))
for k, v := range t {
elems = append(elems, EC.Interface(bestStringAttempt(k), v))
}
doc = DC.Elements(elems...)
case *Element:
doc = DC.Elements(t)
case *Document:
doc = t
case Reader:
doc, err = DC.ReaderErr(t)
case DocumentMarshaler:
doc, err = t.MarshalDocument()
case Marshaler:
doc, err = DC.MarshalerErr(t)
case []*Element:
doc = DC.Elements(t...)
}
if err != nil || doc == nil {
return DC.New()
}
return doc
}
func (DocumentConstructor) InterfaceErr(value interface{}) (*Document, error) {
switch t := value.(type) {
case map[string]string, map[string][]string, map[string]int64, map[string][]int64, map[string]int32, map[string][]int32, map[string]int, map[string][]int, map[string]time.Time, map[string][]time.Time, map[string]time.Duration, map[string][]time.Duration, map[interface{}]interface{}:
return DC.Interface(t), nil
case map[string]Marshaler:
return DC.MapMarshalerErr(t)
case map[string][]Marshaler:
return DC.MapSliceMarshalerErr(t)
case map[string]DocumentMarshaler:
return DC.MapDocumentMarshalerErr(t)
case map[string][]DocumentMarshaler:
return DC.MapSliceDocumentMarshalerErr(t)
case map[string]interface{}:
return DC.MapInterfaceErr(t)
case map[string][]interface{}:
return DC.MapSliceInterfaceErr(t)
case Reader:
return DC.ReaderErr(t)
case *Element:
return DC.Elements(t), nil
case []*Element:
return DC.Elements(t...), nil
case *Document:
return t, nil
case DocumentMarshaler:
return t.MarshalDocument()
case Marshaler:
return DC.MarshalerErr(t)
default:
return nil, fmt.Errorf("value '%s' is of type '%T' which is not convertable to a document.", t, t)
}
}
func (ElementConstructor) Marshaler(key string, val Marshaler) *Element {
elem, err := EC.MarshalerErr(key, val)
if err != nil {
panic(err)
}
return elem
}
func (ElementConstructor) MarshalerErr(key string, val Marshaler) (*Element, error) {
doc, err := val.MarshalBSON()
if err != nil {
return nil, err
}
return EC.SubDocumentFromReader(key, doc), nil
}
func (ElementConstructor) DocumentMarshaler(key string, val DocumentMarshaler) *Element {
doc, err := val.MarshalDocument()
if err != nil {
panic(err)
}
return EC.SubDocument(key, doc)
}
func (ElementConstructor) DocumentMarshalerErr(key string, val DocumentMarshaler) (*Element, error) {
doc, err := val.MarshalDocument()
if err != nil {
return nil, err
}
return EC.SubDocument(key, doc), nil
}
func (ElementConstructor) JSONXErr(key string, val *jsonx.Document) (*Element, error) {
doc, err := DC.JSONXErr(val)
if err != nil {
return nil, err
}
return EC.SubDocument(key, doc), nil
}
func (ElementConstructor) JSONX(key string, val *jsonx.Document) *Element {
return EC.SubDocument(key, DC.JSONX(val))
}
func (ElementConstructor) Int(key string, i int) *Element {
if i < math.MaxInt32 {
return EC.Int32(key, int32(i))
}
return EC.Int64(key, int64(i))
}
func (ElementConstructor) SliceJSONX(key string, in []*jsonx.Document) *Element {
vals := make([]*Value, len(in))
for idx := range in {
vals[idx] = VC.JSONX(in[idx])
}
return EC.Array(key, NewArray(vals...))
}
func (ElementConstructor) SliceString(key string, in []string) *Element {
vals := make([]*Value, len(in))
for idx := range in {
vals[idx] = VC.String(in[idx])
}
return EC.Array(key, NewArray(vals...))
}
func (ElementConstructor) SliceInterface(key string, in []interface{}) *Element {
vals := make([]*Value, len(in))
for idx := range in {
vals[idx] = VC.Interface(in[idx])
}
return EC.Array(key, NewArray(vals...))
}
func (ElementConstructor) SliceInterfaceErr(key string, in []interface{}) (*Element, error) {
vals := make([]*Value, 0, len(in))
for idx := range in {
elem, err := VC.InterfaceErr(in[idx])
if err != nil {
return nil, err
}
if elem != nil {
vals = append(vals, elem)
}
}
return EC.Array(key, NewArray(vals...)), nil
}
func (ElementConstructor) SliceInt64(key string, in []int64) *Element {
vals := make([]*Value, len(in))
for idx := range in {
vals[idx] = VC.Int64(in[idx])
}
return EC.Array(key, NewArray(vals...))
}
func (ElementConstructor) SliceInt32(key string, in []int32) *Element {
vals := make([]*Value, len(in))
for idx := range in {
vals[idx] = VC.Int32(in[idx])
}
return EC.Array(key, NewArray(vals...))
}
func (ElementConstructor) SliceFloat64(key string, in []float64) *Element {
vals := make([]*Value, len(in))
for idx := range in {
vals[idx] = VC.Double(in[idx])
}
return EC.Array(key, NewArray(vals...))
}
func (ElementConstructor) SliceFloat32(key string, in []float32) *Element {
vals := make([]*Value, len(in))
for idx := range in {
vals[idx] = VC.Double(float64(in[idx]))
}
return EC.Array(key, NewArray(vals...))
}
func (ElementConstructor) SliceInt(key string, in []int) *Element {
vals := make([]*Value, len(in))
for idx := range in {
vals[idx] = VC.Int(in[idx])
}
return EC.Array(key, NewArray(vals...))
}
func (ElementConstructor) SliceTime(key string, in []time.Time) *Element {
vals := make([]*Value, len(in))
for idx := range in {
vals[idx] = VC.Time(in[idx])
}
return EC.Array(key, NewArray(vals...))
}
func (ElementConstructor) SliceDuration(key string, in []time.Duration) *Element {
vals := make([]*Value, len(in))
for idx := range in {
vals[idx] = VC.Int64(int64(in[idx]))
}
return EC.Array(key, NewArray(vals...))
}
func (ElementConstructor) SliceMarshaler(key string, in []Marshaler) *Element {
vals := make([]*Value, len(in))
for idx := range in {
vals[idx] = VC.Marshaler(in[idx])
}
return EC.Array(key, NewArray(vals...))
}
func (ElementConstructor) SliceMarshalerErr(key string, in []Marshaler) (*Element, error) {
vals := make([]*Value, 0, len(in))
for idx := range in {
val, err := VC.MarshalerErr(in[idx])
if err != nil {
return nil, err
}
if val != nil {
vals = append(vals, val)
}
}
return EC.Array(key, NewArray(vals...)), nil
}
func (ElementConstructor) SliceDocumentMarshaler(key string, in []DocumentMarshaler) *Element {
vals := make([]*Value, len(in))
for idx := range in {
vals[idx] = VC.DocumentMarshaler(in[idx])
}
return EC.Array(key, NewArray(vals...))
}
func (ElementConstructor) SliceDocumentMarshalerErr(key string, in []DocumentMarshaler) (*Element, error) {
vals := make([]*Value, 0, len(in))
for idx := range in {
val, err := VC.DocumentMarshalerErr(in[idx])
if err != nil {
return nil, err
}
if val != nil {
vals = append(vals, val)
}
}
return EC.Array(key, NewArray(vals...)), nil
}
func (ElementConstructor) Duration(key string, t time.Duration) *Element {
return EC.Int64(key, int64(t))
}
func (ValueConstructor) Int(in int) *Value {
return EC.Int("", in).value
}
func (ValueConstructor) Interface(in interface{}) *Value {
return EC.Interface("", in).value
}
func (ValueConstructor) InterfaceErr(in interface{}) (*Value, error) {
elem, err := EC.InterfaceErr("", in)
if err != nil {
return nil, err
}
return elem.value, nil
}
func (ValueConstructor) Marshaler(in Marshaler) *Value {
return EC.Marshaler("", in).value
}
func (ValueConstructor) MarshalerErr(in Marshaler) (*Value, error) {
elem, err := EC.MarshalerErr("", in)
if err != nil {
return nil, err
}
return elem.value, nil
}
func (ValueConstructor) DocumentMarshaler(in DocumentMarshaler) *Value {
return EC.DocumentMarshaler("", in).value
}
func (ValueConstructor) DocumentMarshalerErr(in DocumentMarshaler) (*Value, error) {
elem, err := EC.DocumentMarshalerErr("", in)
if err != nil {
return nil, err
}
return elem.value, nil
}
func (ValueConstructor) JSONXErr(in *jsonx.Document) (*Value, error) {
elem, err := EC.JSONXErr("", in)
if err != nil {
return nil, err
}
return elem.value, nil
}
func (ValueConstructor) JSONX(in *jsonx.Document) *Value {
return EC.JSONX("", in).value
}
func (ValueConstructor) Duration(t time.Duration) *Value {
return VC.Int64(int64(t))
}
func (ValueConstructor) MapString(in map[string]string) *Value {
return EC.SubDocument("", DC.MapString(in)).value
}
func (ValueConstructor) MapSliceString(in map[string][]string) *Value {
return EC.SubDocument("", DC.MapSliceString(in)).value
}
func (ValueConstructor) MapInt(in map[string]int) *Value {
return EC.SubDocument("", DC.MapInt(in)).value
}
func (ValueConstructor) MapInt32(in map[string]int32) *Value {
return EC.SubDocument("", DC.MapInt32(in)).value
}
func (ValueConstructor) MapInt64(in map[string]int64) *Value {
return EC.SubDocument("", DC.MapInt64(in)).value
}
func (ValueConstructor) MapFloat32(in map[string]float32) *Value {
return EC.SubDocument("", DC.MapFloat32(in)).value
}
func (ValueConstructor) MapFloat64(in map[string]float64) *Value {
return EC.SubDocument("", DC.MapFloat64(in)).value
}
func (ValueConstructor) MapSliceInt(in map[string][]int) *Value {
return EC.SubDocument("", DC.MapSliceInt(in)).value
}
func (ValueConstructor) MapSliceInt32(in map[string][]int32) *Value {
return EC.SubDocument("", DC.MapSliceInt32(in)).value
}
func (ValueConstructor) MapSliceInt64(in map[string][]int64) *Value {
return EC.SubDocument("", DC.MapSliceInt64(in)).value
}
func (ValueConstructor) MapSliceFloat32(in map[string][]float32) *Value {
return EC.SubDocument("", DC.MapSliceFloat32(in)).value
}
func (ValueConstructor) MapSliceFloat64(in map[string][]float64) *Value {
return EC.SubDocument("", DC.MapSliceFloat64(in)).value
}
func (ValueConstructor) MapInterface(in map[string]interface{}) *Value {
return EC.SubDocument("", DC.MapInterface(in)).value
}
func (ValueConstructor) MapSliceInterface(in map[string][]interface{}) *Value {
return EC.SubDocument("", DC.MapSliceInterface(in)).value
}
func (ValueConstructor) MapMarshaler(in map[string]Marshaler) *Value {
return EC.SubDocument("", DC.MapMarshaler(in)).value
}
func (ValueConstructor) MapSliceMarshaler(in map[string][]Marshaler) *Value {
return EC.SubDocument("", DC.MapSliceMarshaler(in)).value
}
func (ValueConstructor) MapTime(in map[string]time.Time) *Value {
return EC.SubDocument("", DC.MapTime(in)).value
}
func (ValueConstructor) MapSliceTime(in map[string][]time.Time) *Value {
return EC.SubDocument("", DC.MapSliceTime(in)).value
}
func (ValueConstructor) MapDuration(in map[string]time.Duration) *Value {
return EC.SubDocument("", DC.MapDuration(in)).value
}
func (ValueConstructor) MapSliceDuration(in map[string][]time.Duration) *Value {
return EC.SubDocument("", DC.MapSliceDuration(in)).value
}
func (ValueConstructor) MapInterfaceErr(in map[string]interface{}) (*Value, error) {
doc, err := DC.MapInterfaceErr(in)
if err != nil {
return nil, err
}
return EC.SubDocument("", doc).value, nil
}
func (ValueConstructor) MapSliceInterfaceErr(in map[string][]interface{}) (*Value, error) {
doc, err := DC.MapSliceInterfaceErr(in)
if err != nil {
return nil, err
}
return EC.SubDocument("", doc).value, nil
}
func (ValueConstructor) MapMarshalerErr(in map[string]Marshaler) (*Value, error) {
doc, err := DC.MapMarshalerErr(in)
if err != nil {
return nil, err
}
return EC.SubDocument("", doc).value, nil
}
func (ValueConstructor) MapSliceMarshalerErr(in map[string][]Marshaler) (*Value, error) {
doc, err := DC.MapSliceMarshalerErr(in)
if err != nil {
return nil, err
}
return EC.SubDocument("", doc).value, nil
}
func (ValueConstructor) MapJSONX(in map[string]*jsonx.Document) *Value {
doc := DC.Make(len(in))
for k, v := range in {
doc.Append(EC.JSONX(k, v))
}
return EC.SubDocument("", doc).value
}
func (ValueConstructor) MapSliceJSONX(in map[string][]*jsonx.Document) *Value {
doc := DC.Make(len(in))
for k, v := range in {
doc.Append(EC.SliceJSONX(k, v))
}
return EC.SubDocument("", doc).value
}
func (ValueConstructor) SliceString(in []string) *Value { return EC.SliceString("", in).value }
func (ValueConstructor) SliceInt(in []int) *Value { return EC.SliceInt("", in).value }
func (ValueConstructor) SliceInt64(in []int64) *Value { return EC.SliceInt64("", in).value }
func (ValueConstructor) SliceInt32(in []int32) *Value { return EC.SliceInt32("", in).value }
func (ValueConstructor) SliceFloat64(in []float64) *Value { return EC.SliceFloat64("", in).value }
func (ValueConstructor) SliceFloat32(in []float32) *Value { return EC.SliceFloat32("", in).value }
func (ValueConstructor) SliceTime(in []time.Time) *Value { return EC.SliceTime("", in).value }
func (ValueConstructor) SliceDuration(in []time.Duration) *Value {
return EC.SliceDuration("", in).value
}
func (ValueConstructor) SliceMarshaler(in []Marshaler) *Value { return EC.SliceMarshaler("", in).value }
func (ValueConstructor) SliceInterface(in []interface{}) *Value {
return EC.SliceInterface("", in).value
}
func (ValueConstructor) SliceMarshalerErr(in []Marshaler) (*Value, error) {
elem, err := EC.SliceMarshalerErr("", in)
if err != nil {
return nil, err
}
return elem.value, nil
}
func (ValueConstructor) SliceInterfaceErr(in []interface{}) (*Value, error) {
elem, err := EC.SliceInterfaceErr("", in)
if err != nil {
return nil, err
}
return elem.value, nil
} | x_constructor.go | 0.724578 | 0.41253 | x_constructor.go | starcoder |
package qrad
import (
"math"
"math/cmplx"
)
type Gate struct {
Matrix Matrix
Name string
// Draw
IsBoxed bool
Symbol string
}
func (g Gate) Operands() int {
return int(math.Log2(float64(g.Matrix.Height)))
}
func (g Gate) IsControl() bool {
return g.Symbol == "C" && g.Matrix.Height == 0
}
var NotGate = Gate{
Matrix: *NewMatrixFromElements([][]Complex{
{Complex(complex(0, 0)), Complex(complex(1, 0))},
{Complex(complex(1, 0)), Complex(complex(0, 0))},
}),
Name: "<NAME>",
Symbol: "X",
IsBoxed: true,
}
var X = NotGate
var PauliXGate = NotGate
var HadamardGate = Gate{
Matrix: *NewMatrixFromElements([][]Complex{
{Complex(complex(1/math.Sqrt(2), 0)), Complex(complex(1/math.Sqrt(2), 0))},
{Complex(complex(1/math.Sqrt(2), 0)), Complex(complex(-1/math.Sqrt(2), 0))},
}),
Name: "Hadamard",
Symbol: "H",
IsBoxed: true,
}
var H = HadamardGate
var IdentityGate = Gate{
Matrix: *NewMatrixFromElements([][]Complex{
{Complex(complex(1, 0)), Complex(complex(0, 0))},
{Complex(complex(0, 0)), Complex(complex(1, 0))},
}),
Name: "Identity",
Symbol: "I",
IsBoxed: true,
}
var I = IdentityGate
func ConstructNIdentity(s int) Gate {
out := NewMatrix()
for i := 0; i < s; i++ {
out.TensorProduct(*out, I.Matrix)
}
return Gate{Matrix: *out, Symbol: "I", Name: "Identity", IsBoxed: true}
}
var PauliZGate = Gate{
Matrix: *NewMatrixFromElements([][]Complex{
{Complex(complex(1, 0)), Complex(complex(0, 0))},
{Complex(complex(0, 0)), Complex(complex(-1, 0))},
}),
Name: "<NAME>",
Symbol: "Z",
IsBoxed: true,
}
var SGate = Gate{
Matrix: *NewMatrixFromElements([][]Complex{
{Complex(complex(1, 0)), Complex(complex(0, 0))},
{Complex(complex(0, 0)), Complex(cmplx.Exp(1i * math.Pi / 2))},
}),
IsBoxed: true,
Name: "S",
Symbol: "S",
}
var SdGate = Gate{
Matrix: *NewMatrixFromElements([][]Complex{
{Complex(complex(1, 0)), Complex(complex(0, 0))},
{Complex(complex(0, 0)), Complex(cmplx.Exp(-1i * math.Pi / 2))},
}),
Name: "Sd",
Symbol: "Sd",
IsBoxed: true,
}
var TGate = Gate{
Matrix: *NewMatrixFromElements([][]Complex{
{Complex(complex(1, 0)), Complex(complex(0, 0))},
{Complex(complex(0, 0)), Complex(cmplx.Exp(1i * math.Pi / 4))},
}),
Name: "T",
Symbol: "T",
IsBoxed: true,
}
var TdGate = Gate{
Matrix: *NewMatrixFromElements([][]Complex{
{Complex(complex(1, 0)), Complex(complex(0, 0))},
{Complex(complex(0, 0)), Complex(cmplx.Exp(-1i * math.Pi / 4))},
}),
Name: "T",
Symbol: "Td",
IsBoxed: true,
}
var CNOT = Gate{
Matrix: *NewMatrixFromElements([][]Complex{
{Complex(complex(1, 0)), Complex(complex(0, 0)), Complex(complex(0, 0)), Complex(complex(0, 0))},
{Complex(complex(0, 0)), Complex(complex(1, 0)), Complex(complex(0, 0)), Complex(complex(0, 0))},
{Complex(complex(0, 0)), Complex(complex(0, 0)), Complex(complex(0, 0)), Complex(complex(1, 0))},
{Complex(complex(0, 0)), Complex(complex(0, 0)), Complex(complex(1, 0)), Complex(complex(0, 0))},
}),
Name: "Controlled Not",
Symbol: "CNOT",
IsBoxed: false,
}
func ROT(angle float64, symbol string) Gate {
return Gate{
Matrix: *NewMatrixFromElements([][]Complex{
{Complex(complex(1, 0)), Complex(complex(0, 0))},
{Complex(complex(0, 0)), Complex(cmplx.Exp(1i * complex(angle, 0)))},
}),
Name: "ROT",
Symbol: symbol,
IsBoxed: false,
}
}
func SWAP(gap int) Gate {
bits := gap + 2
m := ConstructNIdentity(bits).Matrix
length := int(math.Pow(2, float64(bits)))
offset := length/2 - 1
for i := 1; i < length/2; i += 2 {
m.Set(i, i, NewComplex(0, 0))
m.Set(i+offset, i, NewComplex(1, 0))
m.Set(i, i+offset, NewComplex(1, 0))
}
for i := length / 2; i < length; i += 2 {
m.Set(i, i, NewComplex(0, 0))
}
return Gate{
Matrix: m,
Name: "SWAP",
Symbol: "X",
IsBoxed: false,
}
} | gates.go | 0.683314 | 0.564579 | gates.go | starcoder |
package main
import (
blt "bearlibterminal"
"errors"
)
const (
VectorColorNeutral = "white"
VectorColorGood = "green"
VectorColorBad = "red"
VectorWhyInspect = "inspect"
VectorWhyTarget = "target"
)
type Vector struct {
/* Vector is struct that is supposed to help
with creating simple, straight lines between
two points. It has start point, target point,
and slice of bools.
These bools should be set to false by default.
For every passable tile from Start to Target,
one bool will be changed to true. */
StartX int
StartY int
TargetX int
TargetY int
Values []bool
TilesX []int
TilesY []int
}
func NewVector(sx, sy, tx, ty int) (*Vector, error) {
/* Function NewVector creates new Vector with sx, sy as sources coords and
tx, ty as target coords. Vector has length also, and number of
"false" Values is equal to 1 + distance between source and target. */
var err error
if sx < 0 || sx >= MapSizeX || sy < 0 || sy >= MapSizeY ||
tx < 0 || tx >= MapSizeX || ty < 0 || ty >= MapSizeY {
txt := VectorCoordinatesOutOfMapBounds(sx, sy, tx, ty)
err = errors.New("Vector coordinates are out of map bounds." + txt)
}
length := DistanceBetween(sx, sy, tx, ty)
values := make([]bool, length+1)
newVector := &Vector{sx, sy, tx, ty, values,
[]int{}, []int{}}
return newVector, err
}
func ComputeVector(vec *Vector) int {
/* Function ComputeVector takes *Vector as argument.
It uses Brensenham's Like algorithm to compute tile values
(stored in initially empty TilesX and TilesY) between
starting point (vec.StartX, vec.StartY) and goal
(vec.TargetX, vec.TargetY). */
vec.TilesX = nil
vec.TilesY = nil
sx, sy := vec.StartX, vec.StartY
tx, ty := vec.TargetX, vec.TargetY
steep := AbsoluteValue(ty-sy) > AbsoluteValue(tx-sx)
if steep == true {
sx, sy = sy, sx
tx, ty = ty, tx
}
rev := false
if sx > tx {
sx, tx = tx, sx
sy, ty = ty, sy
rev = true
}
dx := tx - sx
dy := AbsoluteValue(ty - sy)
errValue := dx / 2
y := sy
var stepY int
if sy < ty {
stepY = 1
} else {
stepY = -1
}
for x := sx; x <= tx; x++ {
if steep == true {
vec.TilesX = append(vec.TilesX, y)
vec.TilesY = append(vec.TilesY, x)
} else {
vec.TilesX = append(vec.TilesX, x)
vec.TilesY = append(vec.TilesY, y)
}
errValue -= dy
if errValue < 0 {
y += stepY
errValue += dx
}
}
if rev == true {
vec.TilesX = ReverseIntSlice(vec.TilesX)
vec.TilesY = ReverseIntSlice(vec.TilesY)
}
trueLength := len(vec.TilesX)
return trueLength
}
func FindVectorDirection(vec *Vector) ([]int, []int) {
/* FindVectorDirection is function that takes Vector as argument
and returns two slices of ints.
This function is supposed to find pattern of Brensenham's line,
and use it as direction indicator in ExtrapolateVector function. */
var dx = []int{}
var dy = []int{}
for x := 1; x < len(vec.TilesX); x++ {
for y := 1; y < len(vec.TilesY); y++ {
if vec.TilesX[x] > vec.TilesX[x-1] {
dx = append(dx, 1)
} else if vec.TilesX[x] < vec.TilesX[x-1] {
dx = append(dx, -1)
} else {
dx = append(dx, 0)
}
if vec.TilesY[y] > vec.TilesY[y-1] {
dy = append(dy, 1)
} else if vec.TilesY[y] < vec.TilesY[y-1] {
dy = append(dy, -1)
} else {
dy = append(dy, 0)
}
}
}
return dx, dy
}
func ExtrapolateVector(vec *Vector, dx, dy []int) *Vector {
/* Function ExtrapolateVector takes Vector and two slices of ints
as arguments, and returns new Vector.
It uses slices as direction indicator, pattern - dx may look like
[0, 0, 1, 0, 0] - and while iterating ad infinitum, these values
will be added to existing ones. For example, if current vector
goes in horizontal x 10, 11, 12, it will indicate that every one
tile x grows. */
startX, startY := vec.TargetX, vec.TargetY
var newTilesX = vec.TilesX
var newTilesY = vec.TilesY
i := 0
for {
newX, newY := startX+dx[i], startY+dy[i]
if newX < 0 || newX >= MapSizeX || newY < 0 || newY >= MapSizeY {
break
}
newTilesX = append(newTilesX, newX)
newTilesY = append(newTilesY, newY)
startX, startY = newX, newY
i++
if i == len(dx) {
i = 0
}
}
values := make([]bool, len(newTilesX)+1)
newVector := &Vector{vec.StartY, vec.StartX,
vec.TargetX, vec.TargetY, values, newTilesX, newTilesY}
return newVector
}
func ValidateVector(vec *Vector, b Board, c Creatures) (bool, *Tile, *Creature) {
/* Function ValidateVector takes Vector and Board as arguments.
It is important function for ranged combat visualisation - function
checks if line is not blocked by map tiles or other creatures,
or objects. Returns first blocked value.
Four values to return looks bad, but it may be better than
code duplication if there would be three different functions
for Tile, Creature and Object. */
var tile *Tile
var monster *Creature
valid := false
length := len(vec.TilesX)
Loop:
for i := 0; i < length; i++ {
x, y := vec.TilesX[i], vec.TilesY[i]
if x == vec.StartX && y == vec.StartY {
continue
}
if b[x][y].Blocked == true {
// Breaks on blocked tiles.
tile = b[x][y]
break
}
for j := 0; j < len(c); j++ {
if x == c[j].X && y == c[j].Y && c[j].Blocked == true {
// Breaks on first enemy.
vec.Values[i] = true
monster = c[j]
break Loop
}
}
vec.Values[i] = true
}
if vec.Values[len(vec.Values)-1] == true {
// Vector is valid - path is passable.
valid = true
}
// Vector is invalid - blocked tiles in path.
return valid, tile, monster
}
func PrintRangedCharacter(x, y int, color string, valid bool) {
blt.Layer(LookLayer)
if valid == true {
var chars = []string{"▁", "▏", "▕", "▔"}
for i, v := range chars {
blt.Layer(LookLayer + i)
ch := "[color=" + color + "]" + v + "[/color]"
blt.Print(x, y, ch)
}
} else {
ch := "[color=" + color + "]" + "X" + "[/color]"
blt.Print(x, y, ch)
}
} | vec.go | 0.504639 | 0.572185 | vec.go | starcoder |
package mesh
import (
"fmt"
"geGoMetry/r3"
"math"
)
type helper struct {
min, max r3.Vector
}
//UPDATE : https://stackoverflow.com/questions/18695346/how-to-sort-a-mapstringint-by-its-values
type distancePair struct {
vector r3.Vector
distance float64
}
type distancePairList []distancePair
func (p distancePairList) Len() int { return len(p) }
func (p distancePairList) Less(i, j int) bool { return p[i].distance < p[j].distance }
func (p distancePairList) Swap(i, j int) { p[i], p[j] = p[j], p[i] }
func getNearestPoint(vertices []r3.Vector, centroid r3.Vector) r3.Vector {
minDistance := math.MaxFloat64
nearestPoint := r3.Vector{}
for _, vertex := range vertices {
distance := r3.Distance(vertex, centroid)
fmt.Println("distance", distance, " point:", vertex, " nearestPoint:", nearestPoint)
if distance <= minDistance {
minDistance = distance
nearestPoint = vertex
}
}
return nearestPoint
}
func (h *helper) findExtremas(points ...r3.Vector) {
h.min = r3.Vector{X: math.MaxFloat64, Y: math.MaxFloat64, Z: math.MaxFloat64}
h.max = r3.Vector{X: -math.MaxFloat64, Y: -math.MaxFloat64, Z: -math.MaxFloat64}
for _, point := range points {
if h.max.X < point.X {
h.max.X = point.X
}
if h.max.Y < point.Y {
h.max.Y = point.Y
}
if h.max.Z < point.Z {
h.max.Z = point.Z
}
if h.min.X > point.X {
h.min.X = point.X
}
if h.min.Y > point.Y {
h.min.Y = point.Y
}
if h.min.Z > point.Z {
h.min.Z = point.Z
}
}
//fmt.Println("h.max:", h.max, "\nh.min:", h.min)
}
func (h helper) computeBoundingBox() {
xmin, ymin, zmin := h.min.X, h.min.Y, h.min.Z
xmax, ymax, zmax := h.max.X, h.max.Y, h.max.Z
//bounding box
p1 := r3.Vector{X: xmin, Y: ymin, Z: zmin}
p2 := r3.Vector{X: xmax, Y: ymin, Z: zmin}
p3 := r3.Vector{X: xmin, Y: ymax, Z: zmin}
p4 := r3.Vector{X: xmin, Y: ymin, Z: zmax}
p5 := r3.Vector{X: xmax, Y: ymax, Z: zmin}
p6 := r3.Vector{X: xmin, Y: ymax, Z: zmax}
p7 := r3.Vector{X: xmax, Y: ymin, Z: zmax}
p8 := r3.Vector{X: xmax, Y: ymax, Z: zmax}
boundingBox := make([]r3.Vector, 0)
boundingBox = append(boundingBox, p1, p2, p3, p4, p5, p6, p7, p8)
//fmt.Println(boundingBox)
}
func (h helper) computerInitialTetraPoints() (r3.Vector, r3.Vector, r3.Vector, r3.Vector) {
xmin, ymin, zmin := h.min.X, h.min.Y, h.min.Z
xmax, ymax, zmax := h.max.X, h.max.Y, h.max.Z
xtetra := xmin + 3*(xmax-xmin)
ytetra := ymin + 3*(ymax-ymin)
ztetra := zmin + 3*(zmax-zmin)
//Bounding Tetrahedron
p1 := r3.Vector{X: xmin, Y: ymin, Z: zmin}
p2 := r3.Vector{X: xtetra, Y: ymin, Z: zmin}
p3 := r3.Vector{X: xmin, Y: ytetra, Z: zmin}
p4 := r3.Vector{X: xmin, Y: ymin, Z: ztetra}
return p1, p2, p3, p4
} | meshing/helper.go | 0.632957 | 0.646153 | helper.go | starcoder |
package predicate
// Bool represents a function that accepts a bool and returns a bool if the predicate is validated.
type Bool func(bool) bool
// Int represents a function that accepts a int and returns a bool if the predicate is validated.
type Int func(int) bool
// Int8 represents a function that accepts a int8 and returns a bool if the predicate is validated.
type Int8 func(int8) bool
// Int16 represents a function that accepts a int16 and returns a bool if the predicate is validated.
type Int16 func(int16) bool
// Int32 represents a function that accepts a int32 and returns a bool if the predicate is validated.
type Int32 func(int32) bool
// Int64 represents a function that accepts a int64 and returns a bool if the predicate is validated.
type Int64 func(int64) bool
// Uint represents a function that accepts a uint and returns a bool if the predicate is validated.
type Uint func(uint) bool
// Uint8 represents a function that accepts a uint8 and returns a bool if the predicate is validated.
type Uint8 func(uint8) bool
// Uint16 represents a function that accepts a uint16 and returns a bool if the predicate is validated.
type Uint16 func(uint16) bool
// Uint32 represents a function that accepts a uint32 and returns a bool if the predicate is validated.
type Uint32 func(uint32) bool
// Uint64 represents a function that accepts a uint64 and returns a bool if the predicate is validated.
type Uint64 func(uint64) bool
// Uintptr represents a function that accepts a uintptr and returns a bool if the predicate is validated.
type Uintptr func(uintptr) bool
// Float32 represents a function that accepts a float32 and returns a bool if the predicate is validated.
type Float32 func(float32) bool
// Float64 represents a function that accepts a float64 and returns a bool if the predicate is validated.
type Float64 func(float64) bool
// Complex64 represents a function that accepts a complex64 and returns a bool if the predicate is validated.
type Complex64 func(complex64) bool
// Complex128 represents a function that accepts a complex128 and returns a bool if the predicate is validated.
type Complex128 func(complex128) bool
// Byte represents a function that accepts a byte and returns a bool if the predicate is validated.
type Byte func(byte) bool
// Rune represents a function that accepts a rune and returns a bool if the predicate is validated.
type Rune func(rune) bool
// String represents a function that accepts a string and returns a bool if the predicate is validated.
type String func(string) bool
// Error represents a function that accepts a error and returns a bool if the predicate is validated.
type Error func(error) bool
// Interface represents a function that accepts a interface{} and returns a bool if the predicate is validated.
type Interface func(interface{}) bool
// Bools represents a function that accepts a []bool and returns a bool if the predicate is validated.
type Bools func([]bool) bool
// Ints represents a function that accepts a []int and returns a bool if the predicate is validated.
type Ints func([]int) bool
// Int8s represents a function that accepts a []int8 and returns a bool if the predicate is validated.
type Int8s func([]int8) bool
// Int16s represents a function that accepts a []int16 and returns a bool if the predicate is validated.
type Int16s func([]int16) bool
// Int32s represents a function that accepts a []int32 and returns a bool if the predicate is validated.
type Int32s func([]int32) bool
// Int64s represents a function that accepts a []int64 and returns a bool if the predicate is validated.
type Int64s func([]int64) bool
// Uints represents a function that accepts a []uint and returns a bool if the predicate is validated.
type Uints func([]uint) bool
// Uint8s represents a function that accepts a []uint8 and returns a bool if the predicate is validated.
type Uint8s func([]uint8) bool
// Uint16s represents a function that accepts a []uint16 and returns a bool if the predicate is validated.
type Uint16s func([]uint16) bool
// Uint32s represents a function that accepts a []uint32 and returns a bool if the predicate is validated.
type Uint32s func([]uint32) bool
// Uint64s represents a function that accepts a []uint64 and returns a bool if the predicate is validated.
type Uint64s func([]uint64) bool
// Uintptrs represents a function that accepts a []uintptr and returns a bool if the predicate is validated.
type Uintptrs func([]uintptr) bool
// Float32s represents a function that accepts a []float32 and returns a bool if the predicate is validated.
type Float32s func([]float32) bool
// Float64s represents a function that accepts a []float64 and returns a bool if the predicate is validated.
type Float64s func([]float64) bool
// Complex64s represents a function that accepts a []complex64 and returns a bool if the predicate is validated.
type Complex64s func([]complex64) bool
// Complex128s represents a function that accepts a []complex128 and returns a bool if the predicate is validated.
type Complex128s func([]complex128) bool
// Bytes represents a function that accepts a []byte and returns a bool if the predicate is validated.
type Bytes func([]byte) bool
// Runes represents a function that accepts a []rune and returns a bool if the predicate is validated.
type Runes func([]rune) bool
// Strings represents a function that accepts a []string and returns a bool if the predicate is validated.
type Strings func([]string) bool
// Errors represents a function that accepts a []error and returns a bool if the predicate is validated.
type Errors func([]error) bool
// Interfaces represents a function that accepts a []interface{} and returns a bool if the predicate is validated.
type Interfaces func([]interface{}) bool | functional/predicate/predicate.go | 0.725065 | 0.899784 | predicate.go | starcoder |
package main
import (
"fmt"
"html"
"io"
"strings"
"github.com/dave/dst"
)
// GraphNode is a representation of a node in the AST graph.
type GraphNode struct {
Type string
Value string
Node dst.Node
Edges []*GraphEdge
// Used for keeping track of node position during rendering
level int
seq int
}
func (n *GraphNode) id() string {
return fmt.Sprintf("%s_%d_%d", n.Type, n.level, n.seq)
}
// GraphEdge is a representation of an edge in the AST graph.
type GraphEdge struct {
Dest *GraphNode
Relationship string
}
// CreateDot creates a dot representation of the graph associated with a dst node.
func CreateDot(node dst.Node, out io.Writer) error {
root := NodeToGraphNode(node)
dotGraph, err := WalkGraph(root)
if err != nil {
return err
}
_, err = out.Write([]byte(dotGraph))
return err
}
// WalkGraph walks the graph starting at the argument root and returns
// a graphviz (dot) representation.
func WalkGraph(root *GraphNode) (string, error) {
toProcess := []*GraphNode{root}
processed := []*GraphNode{}
outLines := []string{"digraph {"}
var currLevel int
var currSeq int
// First, loop through the graph nodes to assign proper ids
for {
if len(toProcess) == 0 {
break
}
currNode := toProcess[0]
if currNode.level > currLevel {
currLevel = currNode.level
currSeq = 0
}
currNode.seq = currSeq
currSeq++
processed = append(processed, currNode)
toProcess = toProcess[1:]
for _, edge := range currNode.Edges {
edge.Dest.level = currLevel + 1
toProcess = append(toProcess, edge.Dest)
}
}
// Then, fill out the graph in dot format
for _, node := range processed {
var nodeLabel string
var nodeFormat string
if HasAnnotation(node.Node) {
nodeFormat = ",penwidth=3.0"
}
if node.Value != "" {
nodeLabel = fmt.Sprintf(
"%s<br/><font point-size=\"11.0\" face=\"courier\" color=\"#777777\">%s</font>",
node.Type,
html.EscapeString(node.Value),
)
} else {
nodeLabel = node.Type
}
outLines = append(
outLines,
fmt.Sprintf(
"\t%s[label=<%s>,shape=\"box\"%s]",
node.id(),
nodeLabel,
nodeFormat,
),
)
for _, edge := range node.Edges {
outLines = append(
outLines,
fmt.Sprintf(
"\t%s->%s[label=\"%s\",fontsize=12.0]",
node.id(),
edge.Dest.id(),
edge.Relationship,
),
)
}
}
outLines = append(outLines, "}")
return strings.Join(outLines, "\n"), nil
} | internal/vendor/github.com/segmentio/golines/graph.go | 0.70304 | 0.417746 | graph.go | starcoder |
package openapi
import (
"encoding/json"
)
// TokenBucket Defines a token bucket with a maximum capacity (_size_), an initial burst size (_one_time_burst_) and an interval for refilling purposes (_refill_time_). The refill-rate is derived from _size_ and _refill_time_, and it is the constant rate at which the tokens replenish. The refill process only starts happening after the initial burst budget is consumed. Consumption from the token bucket is unbounded in speed which allows for bursts bound in size by the amount of tokens available. Once the token bucket is empty, consumption speed is bound by the refill-rate.
type TokenBucket struct {
// The total number of tokens this bucket can hold.
Size int64 `json:"size"`
// The initial size of a token bucket.
OneTimeBurst *int64 `json:"one_time_burst,omitempty"`
// The amount of milliseconds it takes for the bucket to refill.
RefillTime int64 `json:"refill_time"`
}
// NewTokenBucket instantiates a new TokenBucket 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 NewTokenBucket(size int64, refillTime int64) *TokenBucket {
this := TokenBucket{}
this.Size = size
this.RefillTime = refillTime
return &this
}
// NewTokenBucketWithDefaults instantiates a new TokenBucket 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 NewTokenBucketWithDefaults() *TokenBucket {
this := TokenBucket{}
return &this
}
// GetSize returns the Size field value
func (o *TokenBucket) GetSize() int64 {
if o == nil {
var ret int64
return ret
}
return o.Size
}
// GetSizeOk returns a tuple with the Size field value
// and a boolean to check if the value has been set.
func (o *TokenBucket) GetSizeOk() (*int64, bool) {
if o == nil {
return nil, false
}
return &o.Size, true
}
// SetSize sets field value
func (o *TokenBucket) SetSize(v int64) {
o.Size = v
}
// GetOneTimeBurst returns the OneTimeBurst field value if set, zero value otherwise.
func (o *TokenBucket) GetOneTimeBurst() int64 {
if o == nil || o.OneTimeBurst == nil {
var ret int64
return ret
}
return *o.OneTimeBurst
}
// GetOneTimeBurstOk returns a tuple with the OneTimeBurst field value if set, nil otherwise
// and a boolean to check if the value has been set.
func (o *TokenBucket) GetOneTimeBurstOk() (*int64, bool) {
if o == nil || o.OneTimeBurst == nil {
return nil, false
}
return o.OneTimeBurst, true
}
// HasOneTimeBurst returns a boolean if a field has been set.
func (o *TokenBucket) HasOneTimeBurst() bool {
if o != nil && o.OneTimeBurst != nil {
return true
}
return false
}
// SetOneTimeBurst gets a reference to the given int64 and assigns it to the OneTimeBurst field.
func (o *TokenBucket) SetOneTimeBurst(v int64) {
o.OneTimeBurst = &v
}
// GetRefillTime returns the RefillTime field value
func (o *TokenBucket) GetRefillTime() int64 {
if o == nil {
var ret int64
return ret
}
return o.RefillTime
}
// GetRefillTimeOk returns a tuple with the RefillTime field value
// and a boolean to check if the value has been set.
func (o *TokenBucket) GetRefillTimeOk() (*int64, bool) {
if o == nil {
return nil, false
}
return &o.RefillTime, true
}
// SetRefillTime sets field value
func (o *TokenBucket) SetRefillTime(v int64) {
o.RefillTime = v
}
func (o TokenBucket) MarshalJSON() ([]byte, error) {
toSerialize := map[string]interface{}{}
if true {
toSerialize["size"] = o.Size
}
if o.OneTimeBurst != nil {
toSerialize["one_time_burst"] = o.OneTimeBurst
}
if true {
toSerialize["refill_time"] = o.RefillTime
}
return json.Marshal(toSerialize)
}
type NullableTokenBucket struct {
value *TokenBucket
isSet bool
}
func (v NullableTokenBucket) Get() *TokenBucket {
return v.value
}
func (v *NullableTokenBucket) Set(val *TokenBucket) {
v.value = val
v.isSet = true
}
func (v NullableTokenBucket) IsSet() bool {
return v.isSet
}
func (v *NullableTokenBucket) Unset() {
v.value = nil
v.isSet = false
}
func NewNullableTokenBucket(val *TokenBucket) *NullableTokenBucket {
return &NullableTokenBucket{value: val, isSet: true}
}
func (v NullableTokenBucket) MarshalJSON() ([]byte, error) {
return json.Marshal(v.value)
}
func (v *NullableTokenBucket) UnmarshalJSON(src []byte) error {
v.isSet = true
return json.Unmarshal(src, &v.value)
} | src/runtime/virtcontainers/pkg/cloud-hypervisor/client/model_token_bucket.go | 0.782247 | 0.401394 | model_token_bucket.go | starcoder |
package twodee
import (
"github.com/go-gl/mathgl/mgl32"
"image"
"image/color"
)
type GridItem interface {
Passable() bool
Opaque() bool
}
type Grid struct {
Width int32
Height int32
BlockSize float32
points []GridItem
}
func NewGrid(w, h, blocksize int32) *Grid {
return &Grid{
points: make([]GridItem, w*h),
Width: w,
Height: h,
BlockSize: float32(blocksize),
}
}
func (g *Grid) Index(x, y int32) int32 {
if x < 0 || y < 0 {
return -1
}
return g.Width*(g.Height-y-1) + x
}
func (g *Grid) Get(x, y int32) GridItem {
return g.GetIndex(g.Index(x, y))
}
func (g *Grid) GetIndex(index int32) GridItem {
if index < 0 || index > g.Width*g.Height {
return nil
}
return g.points[index]
}
func (g *Grid) Set(x, y int32, val GridItem) {
g.SetIndex(g.Index(x, y), val)
}
func (g *Grid) SetIndex(index int32, val GridItem) {
if index < 0 || index > g.Width*g.Height {
return
}
g.points[index] = val
}
func (g *Grid) GetImage(fg, bg color.Color) *image.NRGBA {
var (
img = image.NewNRGBA(image.Rect(0, 0, int(g.Width), int(g.Height)))
item GridItem
)
for x := 0; x < int(g.Width); x++ {
for y := 0; y < int(g.Height); y++ {
item = g.Get(int32(x), int32(y))
if item != nil && item.Passable() {
img.Set(x, y, fg)
} else {
img.Set(x, y, bg)
}
}
}
return img
}
func (g *Grid) squareCollides(bounds mgl32.Vec4, x, y float32) bool {
// Bounds are {minx, miny, maxx, maxy}
// Sizex, sizey are the number of coordinate units a grid entry occupies.
var (
size = g.BlockSize
fudge = float32(0.001) // Prevents item from sticking to wall when we round its coordinates.
minx = int32((bounds[0] + x) / size)
miny = int32((bounds[1] + y) / size)
maxx = int32((bounds[2] + x - fudge) / size)
maxy = int32((bounds[3] + y - fudge) / size)
i int32
j int32
item GridItem
)
for i = minx; i <= maxx; i++ {
for j = miny; j <= maxy; j++ {
item = g.Get(i, j)
if item != nil && item.Passable() {
return true
}
}
}
return false
}
func (g *Grid) FixMove(bounds mgl32.Vec4, move mgl32.Vec2) (out mgl32.Vec2) {
out = move
if g.squareCollides(bounds, out[0], 0.0) {
out[0] = g.GridAligned(bounds[0]) - bounds[0]
}
if g.squareCollides(bounds, out[0], out[1]) {
out[1] = g.GridAligned(bounds[1]) - bounds[1]
}
return
}
func (g *Grid) GridAligned(x float32) float32 {
return g.BlockSize * float32(int32((x/g.BlockSize)+0.5))
}
func (g *Grid) GridPosition(v float32) int32 {
return int32(v / g.BlockSize)
}
func (g *Grid) InversePosition(i int32) float32 {
return float32(i)*g.BlockSize + g.BlockSize/2.0
}
func (g *Grid) CanSee(from, to mgl32.Vec2) bool {
var (
size = g.BlockSize
minx = int32(from[0] / size)
maxx = int32(to[0] / size)
miny = int32(from[1] / size)
maxy = int32(to[1] / size)
slope = float32(maxy-miny) / float32(maxx-minx)
c = float32(miny) - (slope * float32(minx))
x int32
y int32
item GridItem
)
for x = minx; x <= maxx; x++ {
y = int32(slope*float32(x) + c)
item = g.Get(x, y)
if item != nil && item.Opaque() {
// Something blocks the way
return false
}
}
for y = miny; y <= maxy; y++ {
x = int32((float32(y) - c) / slope)
item = g.Get(x, y)
if item != nil && item.Opaque() {
// Something blocks the way
return false
}
}
return true
} | grid.go | 0.731826 | 0.453504 | grid.go | starcoder |
package bps
import "math/big"
// rawValue returns the row value as new big.Int instance
func (b *BPS) rawValue() *big.Int {
s := nilSafe(b)
return new(big.Int).Set(s.value)
}
// PPBs returns the row value that means PPB.
func (b *BPS) PPBs() *big.Int {
return b.rawValue()
}
// PPMs returns the row value that means PPM.
func (b *BPS) PPMs() *big.Int {
return b.Div(DenomPPM).rawValue()
}
// Amounts returns the basis point as an integer amount.
func (b *BPS) Amounts() int64 {
return b.Div(DenomAmount).rawValue().Int64()
}
// Percentages returns the basis point as an integer percentage count.
func (b *BPS) Percentages() *big.Int {
return b.Div(DenomPercentage).rawValue()
}
// BasisPoints returns the basis point as an integer basis point count.
func (b *BPS) BasisPoints() *big.Int {
return b.Div(DenomBasisPoint).rawValue()
}
// HalfBasisPoints returns the basis point as an integer half basis point count.
func (b *BPS) HalfBasisPoints() *big.Int {
return b.Div(DenomHalfBasisPoint).rawValue()
}
// DeciBasisPoints returns the basis point as an integer half basis point count.
func (b *BPS) DeciBasisPoints() *big.Int {
return b.Div(DenomDeciBasisPoint).rawValue()
}
// Rat returns a rational number representation of `b`.
func (b *BPS) Rat() *big.Rat {
mul := big.NewInt(DenomAmount)
num := nilSafe(b).value
return new(big.Rat).SetFrac(num, mul)
}
// Float64 returns the nearest float64 value for `b` and a bool indicating whether f represents `b` exactly.
// If the magnitude of `b` is too large to be represented by a float64, f is an infinity and exact is false.
// The sign of f always matches the sign of `b`, even if f == 0.
func (b *BPS) Float64() (f float64, exact bool) {
return b.Rat().Float64()
}
// BaseUnitAmounts returns amount representation of BaseUnit as generated.
// That means the effective digits is modifiable by BaseUnit.
func (b *BPS) BaseUnitAmounts() *big.Int {
switch BaseUnit {
case DeciBasisPoint:
return b.DeciBasisPoints()
case HalfBasisPoint:
return b.HalfBasisPoints()
case BasisPoint:
return b.BasisPoints()
case Percentage:
return b.Percentages()
case PPM:
return b.PPMs()
}
// default is PPB
return b.rawValue()
}
// nilSafe returns zero value when b is nil or b.value is nil to avoid nil error.
func nilSafe(b *BPS) *BPS {
if b == nil {
return zero
}
if b.value == nil {
return zero
}
return b
} | bps/conv.go | 0.885365 | 0.565719 | conv.go | starcoder |
package iso20022
// Formal document used to record a fact and used as proof of the fact that goods have been insured under an insurance policy.
type InsuranceDataSet1 struct {
// Identifies the insurancedata set
DataSetIdentification *DocumentIdentification1 `xml:"DataSetId"`
// Issuer of the certificate, typically the insurance company or its agent.
Issuer *PartyIdentification26 `xml:"Issr"`
// Issue date of the document.
IssueDate *ISODate `xml:"IsseDt"`
// Date upon which cover under an insurance policy becomes effective.
EffectiveDate *ISODate `xml:"FctvDt,omitempty"`
// Place where the insurance certificate was issued.
PlaceOfIssue *PostalAddress5 `xml:"PlcOfIsse,omitempty"`
// Unique identifier of the document.
InsuranceDocumentIdentification *Max35Text `xml:"InsrncDocId"`
// Transport information relative to the goods that are insured under the insurance policy.
Transport *SingleTransport3 `xml:"Trnsprt,omitempty"`
// Value of the goods as insured under the insurance policy.
InsuredAmount *CurrencyAndAmount `xml:"InsrdAmt"`
// Information about the goods and/or services of a trade transaction.
InsuredGoodsDescription *Max70Text `xml:"InsrdGoodsDesc,omitempty"`
// Description of the conditions and exclusion clauses under which insurance is granted.
InsuranceConditions []*Max350Text `xml:"InsrncConds,omitempty"`
// Standard insurance clauses defined by the Institute of London Underwriters (or the American Institute of marine Underwriters).
InsuranceClauses []*InsuranceClauses1Code `xml:"InsrncClauses,omitempty"`
// Party that is covered under the assurance policy.
Assured *PartyIdentification29Choice `xml:"Assrd"`
// Place where claims under the insurance policy will be paid.
ClaimsPayableAt *PostalAddress5 `xml:"ClmsPyblAt"`
// Currency in which claims, if valid, will be paid.
ClaimsPayableIn *CurrencyCode `xml:"ClmsPyblIn,omitempty"`
}
func (i *InsuranceDataSet1) AddDataSetIdentification() *DocumentIdentification1 {
i.DataSetIdentification = new(DocumentIdentification1)
return i.DataSetIdentification
}
func (i *InsuranceDataSet1) AddIssuer() *PartyIdentification26 {
i.Issuer = new(PartyIdentification26)
return i.Issuer
}
func (i *InsuranceDataSet1) SetIssueDate(value string) {
i.IssueDate = (*ISODate)(&value)
}
func (i *InsuranceDataSet1) SetEffectiveDate(value string) {
i.EffectiveDate = (*ISODate)(&value)
}
func (i *InsuranceDataSet1) AddPlaceOfIssue() *PostalAddress5 {
i.PlaceOfIssue = new(PostalAddress5)
return i.PlaceOfIssue
}
func (i *InsuranceDataSet1) SetInsuranceDocumentIdentification(value string) {
i.InsuranceDocumentIdentification = (*Max35Text)(&value)
}
func (i *InsuranceDataSet1) AddTransport() *SingleTransport3 {
i.Transport = new(SingleTransport3)
return i.Transport
}
func (i *InsuranceDataSet1) SetInsuredAmount(value, currency string) {
i.InsuredAmount = NewCurrencyAndAmount(value, currency)
}
func (i *InsuranceDataSet1) SetInsuredGoodsDescription(value string) {
i.InsuredGoodsDescription = (*Max70Text)(&value)
}
func (i *InsuranceDataSet1) AddInsuranceConditions(value string) {
i.InsuranceConditions = append(i.InsuranceConditions, (*Max350Text)(&value))
}
func (i *InsuranceDataSet1) AddInsuranceClauses(value string) {
i.InsuranceClauses = append(i.InsuranceClauses, (*InsuranceClauses1Code)(&value))
}
func (i *InsuranceDataSet1) AddAssured() *PartyIdentification29Choice {
i.Assured = new(PartyIdentification29Choice)
return i.Assured
}
func (i *InsuranceDataSet1) AddClaimsPayableAt() *PostalAddress5 {
i.ClaimsPayableAt = new(PostalAddress5)
return i.ClaimsPayableAt
}
func (i *InsuranceDataSet1) SetClaimsPayableIn(value string) {
i.ClaimsPayableIn = (*CurrencyCode)(&value)
} | InsuranceDataSet1.go | 0.737631 | 0.404331 | InsuranceDataSet1.go | starcoder |
package gm32
import "fmt"
type Vec2 [2]float32
func (v Vec2) Len() float32 {
return Hypot(v[0], v[1])
}
func (v Vec2) Normalize() Vec2 {
l := 1.0 / v.Len()
return Vec2{v[0] * l, v[1] * l}
}
func (v1 Vec2) Dot(v2 Vec2) float32 {
return v1[0]*v2[0] + v1[1]*v2[1]
}
func (v1 Vec2) Cross(v2 Vec2) float32 {
return v1[0]*v2[1] - v1[1]*v2[0]
}
func (v1 Vec2) Add(v2 Vec2) Vec2 {
return Vec2{v1[0] + v2[0], v1[1] + v2[1]}
}
func (v1 Vec2) Sub(v2 Vec2) Vec2 {
return Vec2{v1[0] - v2[0], v1[1] - v2[1]}
}
func (v Vec2) Mul(c float32) Vec2 {
return Vec2{v[0] * c, v[1] * c}
}
func (v Vec2) Elem() (x, y float32) {
return v[0], v[1]
}
type Vec3 [3]float32
func (v Vec3) Len() float32 {
return Sqrt(v[0]*v[0] + v[1]*v[1] + v[2]*v[2])
}
func (v Vec3) Normalize() Vec3 {
l := 1.0 / v.Len()
return Vec3{v[0] * l, v[1] * l, v[2] * l}
}
func (v1 Vec3) Dot(v2 Vec3) float32 {
return v1[0]*v2[0] + v1[1]*v2[1] + v1[2]*v2[2]
}
func (v1 Vec3) Cross(v2 Vec3) Vec3 {
return Vec3{v1[1]*v2[2] - v1[2]*v2[1], v1[2]*v2[0] - v1[0]*v2[2], v1[0]*v2[1] - v2[1]*v1[0]}
}
func (v1 Vec3) Add(v2 Vec3) Vec3 {
return Vec3{v1[0] + v2[0], v1[1] + v2[1], v1[2] + v2[2]}
}
func (v1 Vec3) Sub(v2 Vec3) Vec3 {
return Vec3{v1[0] - v2[0], v1[1] - v2[1], v1[2] - v2[2]}
}
func (v Vec3) Mul(c float32) Vec3 {
return Vec3{v[0] * c, v[1] * c, v[2] * c}
}
func (v Vec3) Elem() (x, y, z float32) {
return v[0], v[1], v[2]
}
type Vec4 [4]float32
func (v Vec4) Len() float32 {
return Sqrt(v[0]*v[0] + v[1]*v[1] + v[2]*v[2] + v[3]*v[3])
}
func (v Vec4) Normalize() Vec4 {
l := 1.0 / v.Len()
return Vec4{v[0] * l, v[1] * l, v[2] * l, v[3] * l}
}
func (v1 Vec4) Dot(v2 Vec4) float32 {
return v1[0]*v2[0] + v1[1]*v2[1] + v1[2]*v2[2] + v1[3]*v2[3]
}
func (v1 Vec4) Add(v2 Vec4) Vec4 {
return Vec4{v1[0] + v2[0], v1[1] + v2[1], v1[2] + v2[2], v1[3] + v2[3]}
}
func (v1 Vec4) Sub(v2 Vec4) Vec4 {
return Vec4{v1[0] - v2[0], v1[1] - v2[1], v1[2] - v2[2], v1[3] - v2[3]}
}
func (v Vec4) Mul(c float32) Vec4 {
return Vec4{v[0] * c, v[1] * c, v[2] * c, v[3] * c}
}
func (v Vec4) Elem() (x, y, z, w float32) {
return v[0], v[1], v[2], v[3]
}
type Vec struct {
N int
Data []float32
}
func NewVec(n int) func(data ...float32) *Vec {
if n <= 0 {
err := fmt.Errorf("the n parameter must be positive (got %d)", n)
panic(err)
}
ctor := func(data ...float32) *Vec {
if len(data) > n {
err := fmt.Errorf("the number of input values must not be greater than n (%d)", n)
panic(err)
}
o := &Vec{
N: n,
Data: make([]float32, n),
}
copy(o.Data, data)
return o
}
return ctor
}
func (v *Vec) Copy() *Vec {
cp := &Vec{
N: v.N,
Data: make([]float32, v.N),
}
copy(cp.Data, v.Data)
return cp
}
func (v1 *Vec) Add(v2 *Vec) *Vec {
if v1.N != v2.N {
err := fmt.Errorf(
"the first and second vectors have different sized (got %d and %d)",
v1.N, v2.N,
)
panic(err)
}
o := &Vec{
N: v1.N,
Data: make([]float32, v1.N),
}
for i := 0; i < o.N; i++ {
o.Data[i] = v1.Data[i] + v2.Data[i]
}
return o
}
func (v1 *Vec) Sub(v2 *Vec) *Vec {
if v1.N != v2.N {
err := fmt.Errorf(
"the first and second vectors have different sized (got %d and %d)",
v1.N, v2.N,
)
panic(err)
}
o := &Vec{
N: v1.N,
Data: make([]float32, v1.N),
}
for i := 0; i < o.N; i++ {
o.Data[i] = v1.Data[i] - v2.Data[i]
}
return o
}
func (v *Vec) Mul(c float32) *Vec {
o := &Vec{
N: v.N,
Data: make([]float32, v.N),
}
for i := 0; i < o.N; i++ {
o.Data[i] = v.Data[i] * c
}
return o
}
func (v *Vec) Len() float32 {
sum := float32(0)
for i := 0; i < v.N; i++ {
sum += v.Data[i] * v.Data[i]
}
return Sqrt(sum)
}
func (v *Vec) Normalize() *Vec {
o := &Vec{
N: v.N,
Data: make([]float32, v.N),
}
l := 1.0 / v.Len()
for i := 0; i < o.N; i++ {
o.Data[i] = v.Data[i] * l
}
return o
}
func (v1 *Vec) Dot(v2 *Vec) float32 {
if v1.N != v2.N {
err := fmt.Errorf(
"the first and second vectors have different sized (got %d and %d)",
v1.N, v2.N,
)
panic(err)
}
sum := float32(0)
for i := 0; i < v1.N; i++ {
sum += v1.Data[i] * v2.Data[i]
}
return sum
}
func (v *Vec) String() string {
return fmt.Sprint(v.Data)
} | gm32/vec.go | 0.738386 | 0.582135 | vec.go | starcoder |
package alchemist
import (
"fmt"
"log"
"strings"
"unicode"
"unicode/utf8"
)
// Atom is an interface that declares certain types as atoms.
type Atom interface {
Parser
Run(Universe)
}
// SimpleAtom represents a simple atom in the universe.
type SimpleAtom string
// Parse parses a SimpleAtom.
func (a *SimpleAtom) Parse(str string) error {
str = strings.TrimSpace(str)
if strings.HasPrefix(str, "In_") || strings.HasPrefix(str, "Out_") {
return &SyntaxError{}
}
first, _ := utf8.DecodeRune([]byte(str))
if first == utf8.RuneError {
return &SyntaxError{}
}
if !unicode.IsLetter(first) && first != '_' {
return &SyntaxError{}
}
lastIndex := strings.IndexFunc(str, func(r rune) bool {
return !unicode.IsLetter(r) && !unicode.IsDigit(r) && r != '_'
})
if lastIndex == -1 {
lastIndex = len(str)
}
*a = SimpleAtom(str[:lastIndex])
return nil
}
// Run defines what this atom will do in the universe.
func (a *SimpleAtom) Run(u Universe) {
u[*a]++
}
func (a *SimpleAtom) String() string {
return string(*a)
}
// InAtom represents an atom used on the RHS used to add a number
// of atoms to the universe, based on standard input.
type InAtom struct {
AddTo SimpleAtom
}
// Parse parses an InAtom. Always returns SyntaxError.
func (a *InAtom) Parse(str string) error {
str = strings.TrimSpace(str)
const prefix = "In_"
n := strings.Index(str, prefix)
if n != 0 {
return &SyntaxError{}
}
rest := str[len(prefix):]
err := a.AddTo.Parse(rest)
if err != nil {
return err
}
return nil
}
func (a *InAtom) String() string {
return "In_" + a.AddTo.String()
}
// Run defines what this atom will do in the universe.
func (a *InAtom) Run(u Universe) {
var n int
_, err := fmt.Scan(&n)
if err != nil {
log.Fatalln(err)
}
u[a.AddTo] += n
}
// OutStrLitAtom represents an atom used on the RHS to output
// a string literal.
type OutStrLitAtom struct {
Printing string
}
// Parse parses an OutStrLitAtom.
func (a *OutStrLitAtom) Parse(str string) error {
str = strings.TrimSpace(str)
const prefix = "Out_\""
n := strings.Index(str, prefix)
if n != 0 {
return &SyntaxError{}
}
rest := str[len(prefix):]
closingQuote := strings.IndexByte(rest, '"')
if closingQuote == -1 {
return &SyntaxError{}
}
a.Printing = rest[:closingQuote]
return nil
}
// Run defines what this atom will do in the universe.
func (a *OutStrLitAtom) Run(u Universe) {
fmt.Println(a.Printing)
}
func (a *OutStrLitAtom) String() string {
return fmt.Sprintf("Out_%q", a.Printing)
}
// OutSimpleAtom represents an atom used on the RHS to output
// the number of a given atom in the universe.
type OutSimpleAtom struct {
Output SimpleAtom
}
// Parse parses an OutSimpleAtom.
func (a *OutSimpleAtom) Parse(str string) error {
str = strings.TrimSpace(str)
const prefix = "Out_"
n := strings.Index(str, prefix)
if n != 0 {
return &SyntaxError{}
}
rest := str[len(prefix):]
err := a.Output.Parse(rest)
if err != nil {
return err
}
return nil
}
// Run defines what this atom will do in the universe.
func (a *OutSimpleAtom) Run(u Universe) {
fmt.Println(u[a.Output])
}
func (a *OutSimpleAtom) String() string {
return "Out_" + a.Output.String()
} | atom.go | 0.699254 | 0.420719 | atom.go | starcoder |
package reflect
// This file contains a set of debugging functions that are used
// by tests of reflect and some other packages.
import (
"fmt"
"path/filepath"
r "reflect"
"sort"
)
// AssertEqualType gets two *Type arguments and returns nil in case they
// are equal to each other and an error otherwise.
func AssertEqualType(t1, t2 *Type) error {
if t1 == nil || t2 == nil {
if t1 != t2 {
return fmt.Errorf("one of the types is equal to nil while another is not: %#v != %#v", t1, t2)
}
return nil
}
if t1.String() != t2.String() {
return fmt.Errorf("types are not equal: %s != %s", t1, t2)
}
return nil
}
// AssertEqualArg gets two *Arg parameters and returns nil in case they
// are equal and an error otherwise.
func AssertEqualArg(a1, a2 *Arg) error {
if a1 == nil || a2 == nil {
if a1 != a2 {
return fmt.Errorf("one of the arguments is nil while another is not: %#v != %#v", a1, a2)
}
return nil
}
if a1.Name != a2.Name {
return fmt.Errorf("arguments have different names: %s != %s", a1.Name, a2.Name)
}
if a1.Tag != a2.Tag {
return fmt.Errorf("arguments have different tags: %s != %s", a1.Tag, a2.Tag)
}
return AssertEqualType(a1.Type, a2.Type)
}
// AssertEqualArgs gets two lists of arguments and returns nil if they are
// equal to each other and an error otherwise.
func AssertEqualArgs(as1, as2 Args) error {
if len(as1) != len(as2) {
return fmt.Errorf(
"Argument slices %#v and %#v have different length: %d != %d.",
as1, as2, len(as1), len(as2),
)
}
for i := range as1 {
if err := AssertEqualArg(&as1[i], &as2[i]); err != nil {
return err
}
}
return nil
}
// AssertEqualFunc returns nil if received functions are equal to each other
// and an error otherwise.
func AssertEqualFunc(f1, f2 *Func) error {
if f1 == nil || f2 == nil {
if f1 != f2 {
return fmt.Errorf("one of the funcs is nil while another is not: %#v != %#v", f1, f2)
}
return nil
}
if f1.Name != f2.Name {
return fmt.Errorf("functions have different names: %s != %s", f1.Name, f2.Name)
}
if filepath.Base(f1.File) != filepath.Base(f2.File) {
return fmt.Errorf("functions are from different files: %s != %s", f1.File, f2.File)
}
if !r.DeepEqual(f1.Comments, f2.Comments) {
return fmt.Errorf("Comments of funcs are not equal: %#v != %#v.", f1.Comments, f2.Comments)
}
if err := AssertEqualArg(f1.Recv, f2.Recv); err != nil {
return err
}
if err := AssertEqualArgs(f1.Params, f2.Params); err != nil {
return err
}
return AssertEqualArgs(f1.Results, f2.Results)
}
// AssertEqualFuncs returns nil if received function slices are equal to each other
// and an error otherwise.
func AssertEqualFuncs(fs1, fs2 Funcs) error {
if len(fs1) != len(fs2) {
return fmt.Errorf(
"func slices %#v and %#v have different length: %d != %d",
fs1, fs2, len(fs1), len(fs2),
)
}
// Sort slices to fix #15.
sort.Sort(fs1)
sort.Sort(fs2)
for i := range fs1 {
if err := AssertEqualFunc(&fs1[i], &fs2[i]); err != nil {
return err
}
}
return nil
}
// AssertEqualStruct gets two *Struct arguments and makes sure they are equal.
// If they are a nil is returned. Otherwise, it will return an error.
func AssertEqualStruct(s1, s2 *Struct) error {
if s1 == nil || s2 == nil {
if s1 != s2 {
return fmt.Errorf("one of the structs is nil while another is not: %#v != %#v", s1, s2)
}
return nil
}
if s1.Name != s2.Name {
return fmt.Errorf("structures have different names: %s != %s", s1.Name, s2.Name)
}
if filepath.Base(s1.File) != filepath.Base(s2.File) {
return fmt.Errorf("structures are from different files: %s != %s", s1.File, s2.File)
}
if !r.DeepEqual(s1.Comments, s2.Comments) {
return fmt.Errorf("comments of structs are not equal: %#v != %#v", s1.Comments, s2.Comments)
}
return AssertEqualArgs(s1.Fields, s2.Fields)
}
// AssertEqualStructs checks whether two slices of Structs are equal.
// If they are nil is returned. Otherwise, it will return an error.
func AssertEqualStructs(ss1, ss2 Structs) error {
if len(ss1) != len(ss2) {
return fmt.Errorf(
"struct slices %#v and %#v have different length: %d and %d",
ss1, ss2, len(ss1), len(ss2),
)
}
for i := range ss1 {
if err := AssertEqualStruct(&ss1[i], &ss2[i]); err != nil {
return err
}
}
return nil
}
// AssertEqualMethods returns nil if received maps of methods are equal to each other
// and an error otherwise.
func AssertEqualMethods(ms1, ms2 Methods) error {
if len(ms1) != len(ms2) {
return fmt.Errorf(
"methods maps %#v and %#v have different length: %d != %d",
ms1, ms2, len(ms1), len(ms2),
)
}
for k := range ms1 {
if err := AssertEqualFuncs(ms1[k], ms2[k]); err != nil {
return err
}
}
return nil
}
// AssertEqualPkg makes sure two packages are equal to each other.
// If they are nil is returned. Otherwise, it returns an error.
func AssertEqualPkg(p1, p2 *Package) error {
if p1 == nil || p2 == nil {
if p1 != p2 {
return fmt.Errorf("one of the packages is nil while another is not: %#v != %#v", p1, p2)
}
return nil
}
if p1.Name != p2.Name {
return fmt.Errorf("packages have different names: %s != %s", p1.Name, p2.Name)
}
if !r.DeepEqual(p1.Imports, p2.Imports) {
return fmt.Errorf("imports of packages are not equal: %#v != %#v", p1.Imports, p2.Imports)
}
if err := AssertEqualStructs(p1.Structs, p2.Structs); err != nil {
return err
}
if err := AssertEqualFuncs(p1.Funcs, p2.Funcs); err != nil {
return err
}
return AssertEqualMethods(p1.Methods, p2.Methods)
} | internal/reflect/equal.go | 0.67104 | 0.549036 | equal.go | starcoder |
package graphtweets
import "github.com/dghubble/go-twitter/twitter"
// Edges a list of edges and their occurrences
type Edges struct {
Source []string `json:"source"`
Target []string `json:"target"`
Number []int `json:"weight"`
}
// Nodes a list of nodes and their occurrences
type Nodes struct {
Name []string `json:"name"`
Number []int `json:"size"`
}
// Graph a list containing nodes and edges
type Graph struct {
Nodes Nodes
Edges Edges
}
// GetNodes Get the nodes from the edges
func GetNodes(edges *Edges) Nodes {
encountered := map[string]int{}
// Create a map of all unique elements.
for v := range edges.Source {
encountered[edges.Source[v]] = encountered[edges.Source[v]] + 1
}
for v := range edges.Target {
encountered[edges.Target[v]] = encountered[edges.Target[v]] + 1
}
// Place all keys from the map into a slice.
result := []string{}
count := []int{}
for key, index := range encountered {
result = append(result, key)
count = append(count, index)
}
nodes := Nodes{result, count}
return (nodes)
}
// GetMentionEdges construct edges of mentions
// where the source of the edge is the user tweeting
// and the target is the user(s) tagged in the tweet(s).
func GetMentionEdges(search twitter.Search) Edges {
fr := make([]string, 0)
to := make([]string, 0)
for _, v := range search.Statuses {
userMention := v.Entities.UserMentions
for _, v := range userMention {
fr = append(fr, v.ScreenName)
}
for i := 0; i < len(userMention); i++ {
to = append(to, v.User.ScreenName)
}
}
cn := make([]int, len(to))
edges := Edges{fr, to, cn}
countEdges(&edges)
return (edges)
}
// GetRetweetEdges construct edges of retweets
// where the source of the edge is the user tweeting
// and the target is the user retweeted.
func GetRetweetEdges(search twitter.Search) Edges {
fr := make([]string, 0)
to := make([]string, 0)
for _, v := range search.Statuses {
to = append(to, v.InReplyToScreenName)
fr = append(fr, v.User.ScreenName)
}
cn := make([]int, len(to))
edges := Edges{fr, to, cn}
countEdges(&edges)
return (edges)
}
// GetHashtagEdges
// where the source of the edge is the user tweeting
// and the target is the hashtag used in the tweet.
func GetHashtagEdges(search twitter.Search) Edges {
fr := make([]string, 0)
to := make([]string, 0)
for _, v := range search.Statuses {
hashtag := v.Entities.Hashtags
for _, v := range hashtag {
fr = append(fr, v.Text)
}
for i := 0; i < len(hashtag); i++ {
to = append(to, v.User.ScreenName)
}
}
cn := make([]int, len(to))
edges := Edges{fr, to, cn}
countEdges(&edges)
return (edges)
}
func countEdges(edges *Edges) {
ed := make(map[string]string)
occ := edges.Number
for i := range edges.Source {
if _, ok := ed[edges.Source[i]]; !ok {
ed[edges.Source[i]] = edges.Target[i]
occ[i] = occ[i] + 1
} else {
occ[i] = occ[i] + 1
}
}
*edges = Edges{edges.Source, edges.Target, occ}
} | graphtweets/utils.go | 0.650911 | 0.45538 | utils.go | starcoder |
package musictheory
import (
"fmt"
"math"
)
// Quality types
const (
PerfectType QualityType = iota
MajorType
MinorType
AugmentedType
DiminishedType
)
// IntervalFunc creates an interval at as specific step/degree
type IntervalFunc func(int) Interval
// Perfect interval
func Perfect(step int) Interval {
return qualityInterval(step, Quality{PerfectType, 0})
}
// Major interval
func Major(step int) Interval {
return qualityInterval(step, Quality{MajorType, 0})
}
// Minor interval
func Minor(step int) Interval {
return qualityInterval(step, Quality{MinorType, 0})
}
// Augmented interval
func Augmented(step int) Interval {
return qualityInterval(step, Quality{AugmentedType, 1})
}
// DoublyAugmented interval
func DoublyAugmented(step int) Interval {
return qualityInterval(step, Quality{AugmentedType, 2})
}
// Diminished interval
func Diminished(step int) Interval {
return qualityInterval(step, Quality{DiminishedType, 1})
}
// DoublyDiminished interval
func DoublyDiminished(step int) Interval {
return qualityInterval(step, Quality{DiminishedType, 2})
}
// Octave interval
func Octave(step int) Interval {
return Interval{step, 0, 0}
}
// Semitones is an interval using direct semitones
func Semitones(step int) Interval {
normal := normalizeChromatic(step)
return Interval{chromaticOctaves(step), chromaticToDiatonic(normal), normal}
}
func qualityInterval(step int, quality Quality) Interval {
var (
absStep = int(math.Abs(float64(step)))
diatonic = normalizeDiatonic(absStep - 1)
diff = qualityDiff(quality, canBePerfect(diatonic))
octaves = diatonicOctaves(absStep - 1)
)
i := NewInterval(absStep, octaves, diff)
if step > 0 {
return i
}
return i.Negate()
}
// NewInterval builds a new Interval
func NewInterval(step, octaves, offset int) Interval {
diatonic := normalizeDiatonic(step - 1)
chromatic := diatonicToChromatic(diatonic) + offset
return Interval{octaves, diatonic, chromatic}
}
// Interval represents an interval in 12-tone equal temperament
type Interval struct {
Octaves int
Diatonic int
Chromatic int
}
// Semitones returns the total number of semitones that make up the interval
func (i Interval) Semitones() int {
return i.Octaves*12 + i.Chromatic
}
// Quality returns the Quality
func (i Interval) Quality() Quality {
quality := diffQuality(i.Chromatic-diatonicToChromatic(i.Diatonic), canBePerfect(i.Diatonic))
if i.Octaves < 0 {
return quality.Invert()
}
return quality
}
// Ratio returns the interval ratio
func (i Interval) Ratio() float64 {
return math.Exp2(float64(i.Semitones()) / 12.0)
}
// Transpose returns a new Interval that has been transposed by the given Interval
func (i Interval) Transpose(o Interval) Interval {
var diatonic int
// TODO: Accomodate weird behavior of sequential minor second transpositions. We don't need to advance the diatonic
// every transposition. We're currently modeling things as integers, but maybe we need to model as floats and
// accumulate over time; whole numbers trigger a move.
if o.Diatonic == o.Chromatic {
if diatonicToChromatic(i.Diatonic) == i.Chromatic {
diatonic = i.Diatonic + o.Diatonic
} else {
diatonic = i.Diatonic
}
} else {
diatonic = i.Diatonic + o.Diatonic
}
var (
chromatic = i.Chromatic + o.Chromatic
diatonicRemainder = normalizeDiatonic(diatonic)
octaves = i.Octaves + o.Octaves + chromaticOctaves(chromatic)
finalChromatic = normalizeChromatic(i.Chromatic + o.Chromatic)
)
return Interval{octaves, diatonicRemainder, finalChromatic}
}
// Negate returns a new, negated Interval
func (i Interval) Negate() Interval {
if i.Diatonic == 0 && i.Chromatic == 0 {
return Interval{-i.Octaves, i.Diatonic, i.Chromatic}
}
return Interval{-(i.Octaves + 1), inverseDiatonic(i.Diatonic), inverseChromatic(i.Chromatic)}
}
// Eq determines if another interval is the same
func (i Interval) Eq(o Interval) bool {
return i.Semitones() == o.Semitones()
}
func (i Interval) String() string {
mag := 1
if i.Octaves < 0 {
i = i.Negate()
mag = -1
}
var (
quality = i.Quality()
diatonic = (i.Octaves * 7) + i.Diatonic + 1
)
return fmt.Sprintf("%s %d", quality, mag*diatonic)
}
// QualityType represents the type a Quality can take
type QualityType int
func (q QualityType) String() string {
switch q {
case PerfectType:
return "perfect"
case MajorType:
return "major"
case MinorType:
return "minor"
case AugmentedType:
return "augmented"
case DiminishedType:
return "diminished"
default:
return "unknown"
}
}
// Quality describes the quality of an interval
type Quality struct {
Type QualityType
Size int
}
// Invert returns a new, inverted Quality
func (q Quality) Invert() Quality {
switch q.Type {
case PerfectType:
return q
case MajorType:
return Quality{MinorType, q.Size}
case MinorType:
return Quality{MajorType, q.Size}
case AugmentedType:
return Quality{DiminishedType, q.Size}
case DiminishedType:
return Quality{AugmentedType, q.Size}
default:
panic(fmt.Sprintf("invalid type: %d", q.Type))
}
}
// Eq checks two Qualities for equality
func (q Quality) Eq(o Quality) bool {
return q.Type == o.Type && q.Size == o.Size
}
func (q Quality) String() string {
switch q.Type {
case PerfectType, MajorType, MinorType:
return fmt.Sprintf("%s", q.Type)
case AugmentedType, DiminishedType:
prefix := ""
if q.Size == 2 || q.Size == -2 {
prefix = "doubly "
}
return fmt.Sprintf("%s%s", prefix, q.Type)
default:
return "unknown"
}
}
func diatonicToChromatic(interval int) int {
if interval >= len(diatonicToChromaticLookup) {
panic(fmt.Sprintf("interval out of range: %d", interval))
}
return diatonicToChromaticLookup[interval]
}
var diatonicToChromaticLookup = []int{0, 2, 4, 5, 7, 9, 11}
func chromaticToDiatonic(v int) int {
mag := 1
if v < 0 {
mag = -1
v = -v
}
v = normalizeChromatic(v)
for i, c := range diatonicToChromaticLookup {
if v == c || v < c {
return i * mag
}
}
return 6 * mag
}
func qualityDiff(q Quality, perfect bool) int {
if q.Type == PerfectType || q.Type == MajorType {
return 0
} else if q.Type == MinorType {
return -1
} else if q.Type == AugmentedType {
return q.Size
} else if q.Type == DiminishedType {
if perfect {
return -q.Size
}
return -(q.Size + 1)
}
panic("invalid quality")
}
func diffQuality(diff int, perfect bool) Quality {
if perfect {
if diff == 0 {
return Quality{PerfectType, 0}
} else if diff > 0 {
return Quality{AugmentedType, diff}
}
return Quality{DiminishedType, -diff}
}
if diff == 0 {
return Quality{MajorType, 0}
} else if diff == -1 {
return Quality{MinorType, 0}
} else if diff > 0 {
return Quality{AugmentedType, diff}
}
return Quality{DiminishedType, -(diff + 1)}
}
func canBePerfect(interval int) bool {
return interval == 0 || interval == 3 || interval == 4
} | interval.go | 0.7237 | 0.533033 | interval.go | starcoder |
package hexit
import (
"math"
"math/rand"
tf "github.com/tensorflow/tensorflow/tensorflow/go"
"gonum.org/v1/gonum/stat/distuv"
)
// SearchNode is a node in a search tree
type SearchNode struct {
// Move that led to this node
move Move
// Total number of visits
n uint32
// Value estimate from NN
v float32
// Average value
q float32
// Total value across all visits
w float32
// Policy estimate from NN
p float32
// Does this move end the game?
isTerminal bool
// Other nodes
parent *SearchNode
firstChild *SearchNode
nextSibling *SearchNode
}
// SearchTree is an MCTS search tree
type SearchTree struct {
game Game
rootNode *SearchNode
}
// NewSearchNode creates a new SearchNode
func NewSearchNode(parent *SearchNode, move Move) SearchNode {
nan := float32(math.NaN())
return SearchNode{
move: move,
n: 0,
v: nan,
q: 0,
w: 0,
p: nan,
isTerminal: false,
parent: parent,
firstChild: nil,
nextSibling: nil,
}
}
// NewSearchTree creates a new SearchTree
func NewSearchTree(evaluatePosition Evaluator, game Game) SearchTree {
if GetWinner(game.Board) != 0 {
panic("Can't search from a terminal node")
}
rootNode := NewSearchNode(nil, Move{Row: 1000, Col: 1000})
searchTree := SearchTree{
game: game,
rootNode: &rootNode,
}
EvaluateAtNode(evaluatePosition, searchTree.rootNode, game)
return searchTree
}
// ApplyDirichletNoise applies noise to the root node's policy estimates
func ApplyDirichletNoise(newSearchTree *SearchTree) {
epsilon := float32(0.25)
alpha := 0.3
gammaDistribution := distuv.Gamma{Alpha: alpha, Beta: 1.0}
totalNoise := float32(0)
noiseVector := make([]float32, 0)
for childNode := newSearchTree.rootNode.firstChild; childNode != nil; childNode = childNode.nextSibling {
noise := float32(gammaDistribution.Rand())
noiseVector = append(noiseVector, noise)
totalNoise += noise
}
for i := range noiseVector {
noiseVector[i] /= totalNoise
}
i := 0
for childNode := newSearchTree.rootNode.firstChild; childNode != nil; childNode = childNode.nextSibling {
childNode.p = (1-epsilon)*childNode.p + epsilon*noiseVector[i]
i++
}
}
type Evaluator = func(Board, byte) (float32, [5][5]float32)
// EvaluatePositionRandomly returns random value and policy estimates for a position.
func EvaluatePositionRandomly(board Board, player byte) (float32, [5][5]float32) {
valueEstimate := rand.Float32()*2 - 1
policyEstimates := [5][5]float32{}
for i := 0; i < 5; i++ {
for j := 0; j < 5; j++ {
policyEstimates[i][j] = rand.Float32()
}
}
return valueEstimate, policyEstimates
}
// EvaluatePositionUniformly returns the same value and policy estimates for every position
func EvaluatePositionUniformly(board Board, player byte) (float32, [5][5]float32) {
valueEstimate := float32(0)
policyEstimates := [5][5]float32{}
for i := 0; i < 5; i++ {
for j := 0; j < 5; j++ {
policyEstimates[i][j] = 1.0 / (5 * 5)
}
}
return valueEstimate, policyEstimates
}
var model *tf.SavedModel
func InitializeModel() {
if model == nil {
savedModel, err := tf.LoadSavedModel("hexit_saved_model", []string{"serve"}, nil)
if err != nil {
panic(err)
}
model = savedModel
}
}
func EvaluatePositionWithNN(board Board, player byte) (float32, [5][5]float32) {
if model == nil {
panic("Model not initialized")
}
squaresOccupiedByMyself, squaresOccupiedByOtherPlayer := GetOccupiedSquaresForNN(board, player)
boardInput := [][]float32{
append(squaresOccupiedByMyself, squaresOccupiedByOtherPlayer...),
}
boardInputTensor, err := tf.NewTensor(boardInput)
if err != nil {
panic(err)
}
boardInputOperation := model.Graph.Operation("boardInput")
policyOutputOperation := model.Graph.Operation("policyOutput/Softmax")
valueOutputOperation := model.Graph.Operation("valueOutput/Tanh")
if boardInputOperation == nil {
panic("boardInput operation not found")
}
if policyOutputOperation == nil {
panic("policyOutput operation not found")
}
if valueOutputOperation == nil {
panic("valueOutput operation not found")
}
result, err := model.Session.Run(
map[tf.Output]*tf.Tensor{
boardInputOperation.Output(0): boardInputTensor,
},
[]tf.Output{
policyOutputOperation.Output(0),
valueOutputOperation.Output(0),
},
nil,
)
if err != nil {
panic(err)
}
policyOutputs := result[0].Value().([][]float32)
valueOutputs := result[1].Value().([][]float32)
valueEstimate := float32(0.0)
if player == 1 {
valueEstimate = valueOutputs[0][0]
} else {
valueEstimate = -valueOutputs[0][0]
}
policyEstimates := [5][5]float32{}
for i := 0; i < 5; i++ {
for j := 0; j < 5; j++ {
if player == 1 {
policyEstimates[i][j] = policyOutputs[0][i*5+j]
} else {
policyEstimates[j][i] = policyOutputs[0][i*5+j]
}
}
}
return valueEstimate, policyEstimates
}
// EvaluateAtNode evaluates the NN at a single node.
func EvaluateAtNode(evaluatePosition Evaluator, node *SearchNode, game Game) {
if node.isTerminal {
panic("Should not evaluate the NN at a terminal node")
}
valueEstimate, policyEstimates := evaluatePosition(game.Board, game.CurrentPlayer)
node.v = valueEstimate
firstChildNode := (*SearchNode)(nil)
totalLegalPolicy := float32(0.0)
for i := 0; i < 5; i++ {
for j := 0; j < 5; j++ {
if game.Board[i][j] != 0 {
// Illegal move
continue
}
totalLegalPolicy += policyEstimates[i][j]
childNode := NewSearchNode(node, Move{Row: uint(i), Col: uint(j)})
childNode.p = policyEstimates[i][j]
childNode.nextSibling = firstChildNode
firstChildNode = &childNode
}
}
if firstChildNode == nil {
panic("There should be at least 1 legal move")
}
// Normalize policy
for childNode := firstChildNode; childNode != nil; childNode = childNode.nextSibling {
childNode.p /= totalLegalPolicy
}
node.firstChild = firstChildNode
}
func calculateUctU(node *SearchNode, numParentVisits uint) float32 {
cpuct := float32(1.2)
return cpuct * node.p * float32(
math.Sqrt(float64(numParentVisits)/
float64(1.0+node.n)))
}
// CalculateUctValue computes the priority of a node for exploration (Q+U).
// Nodes with higher values should be explored first.
func CalculateUctValue(node *SearchNode, numParentVisits uint) float32 {
return node.q + calculateUctU(node, numParentVisits)
}
// CalculateFirstMoveUctValue is like CalculateUctValue, but for the very first move.
// The first move should be as close to equal as possible, so instead of Q+U, use U-abs(Q).
func CalculateFirstMoveUctValue(node *SearchNode, numParentVisits uint) float32 {
if node.isTerminal {
// If the move wins the game, Player 2 can't switch sides.
// To make sure Player 1 plays the winning move, use the usual UCT value (Q+U)
return CalculateUctValue(node, numParentVisits)
}
return calculateUctU(node, numParentVisits) - float32(math.Abs(float64(node.q)))
}
// DoVisit performs one iteration of tree search.
func DoVisit(tree *SearchTree, evaluatePosition Evaluator) {
// Select a leaf node to visit
currentNode := tree.rootNode
currentGame := tree.game
var err error
for currentNode.firstChild != nil {
// While we're not at a leaf node:
bestCandidateNode := (*SearchNode)(nil)
bestUctValue := float32(math.Inf(-1))
candidateNode := currentNode.firstChild
for candidateNode != nil {
var uctValue float32
if currentGame.MoveNum == 1 {
uctValue = CalculateFirstMoveUctValue(candidateNode, uint(currentNode.n))
} else {
uctValue = CalculateUctValue(candidateNode, uint(currentNode.n))
}
if math.IsNaN(float64(uctValue)) {
panic("UCT value should not be NaN")
}
if uctValue > bestUctValue {
bestCandidateNode = candidateNode
bestUctValue = uctValue
}
candidateNode = candidateNode.nextSibling
}
currentNode = bestCandidateNode
// Skip the side-switching move
if currentGame.MoveNum == 2 {
err, currentGame = DoNotSwitchSides(currentGame)
if err != nil {
panic(err)
}
}
err, currentGame = PlayGameMove(currentGame, bestCandidateNode.move.Row, bestCandidateNode.move.Col)
if err != nil {
panic(err)
}
}
// Expand the selected leaf node
winner := GetWinner(currentGame.Board)
if winner != 0 {
currentNode.isTerminal = true
currentNode.v = 1
} else {
EvaluateAtNode(evaluatePosition, currentNode, currentGame)
}
// Back up the evaluated value
visitValue := currentNode.v
nodeToUpdate := currentNode
for nodeToUpdate != nil {
nodeToUpdate.w += visitValue
nodeToUpdate.n++
nodeToUpdate.q = nodeToUpdate.w / float32(nodeToUpdate.n)
if nodeToUpdate.parent == nil {
break
}
nodeToUpdate = nodeToUpdate.parent
// Flip value for opponent
visitValue = -visitValue
}
}
// GetBestMove gets the estimated best move at the root of a search tree
func GetBestMove(tree *SearchTree) Move {
maxVisits := -1
bestMove := (*Move)(nil)
for childNode := tree.rootNode.firstChild; childNode != nil; childNode = childNode.nextSibling {
if int(childNode.n) > maxVisits {
maxVisits = int(childNode.n)
bestMove = &childNode.move
}
}
return *bestMove
}
// GetMoveWithTemperatureOne picks a move using a "temperature" of 1.0
// The probability a move is picked is proportional to the number of visits.
func GetMoveWithTemperatureOne(tree *SearchTree) Move {
totalVisits := 0
for childNode := tree.rootNode.firstChild; childNode != nil; childNode = childNode.nextSibling {
totalVisits += int(childNode.n)
}
randInt := rand.Intn(totalVisits)
cumulativeVisits := 0
for childNode := tree.rootNode.firstChild; childNode != nil; childNode = childNode.nextSibling {
cumulativeVisits += int(childNode.n)
if randInt <= cumulativeVisits {
return childNode.move
}
}
panic("Expected to pick a move")
}
// GetExpectedValueOfGame gets the expected value of the game.
// It's +1 if Player 1 will win, and -1 if Player 2 will win.
func GetExpectedValueOfGame(tree *SearchTree) float32 {
if tree.game.MoveNum == 1 {
// Player 2 can switch sides
totalVisits := 0
totalAdjustedQ := float32(0)
for childNode := tree.rootNode.firstChild; childNode != nil; childNode = childNode.nextSibling {
totalVisits += int(childNode.n)
q := childNode.q
if !childNode.isTerminal {
q = float32(-math.Abs(float64(q)))
}
totalAdjustedQ += float32(childNode.n) * q
}
return totalAdjustedQ / float32(totalVisits)
} else if tree.game.MoveNum == 2 {
return float32(
// We can switch sides if the root node's Q is unfavorable
-math.Abs(float64(tree.rootNode.q)),
)
} else if tree.game.CurrentPlayer == 1 {
return -tree.rootNode.q
} else if tree.game.CurrentPlayer == 2 {
return +tree.rootNode.q
} else {
panic("unreachable")
}
}
func ShouldSwitchSides(tree *SearchTree) bool {
if tree.game.MoveNum != 2 {
panic("Can only switch sides on move 2")
}
return tree.rootNode.q > 0
} | src/search.go | 0.773216 | 0.544499 | search.go | starcoder |
package tree
import (
"fmt"
)
// Tree is the basic struct for any tree hierarchy
type Tree struct {
Id string `json:"id"`
Root *Node `json:"root"`
}
// SubordinatesResponse is the base
// response for the GET subordinates route
type SubordinatesResponse struct {
Subordinates SubordinatesInfo `json:"subordinates"`
}
// SubordinatesInfo contains a `count` of subordinates
// and a full `hierarchy` of nodes
type SubordinatesInfo struct {
Count SubordinatesCount `json:"count"`
Hierarchy []*Node `json:"hierarchy,omitempty"`
}
// SubordinatesCount contains a `direct` and a `total`
// count of subordinates
type SubordinatesCount struct {
Direct int `json:"direct"`
Total int `json:"total"`
}
// New will create a new tree given an id
// by default will also create a node with id `root`
func New(id string) *Tree {
rootNode := Node{
ID: "root",
Data: MetaData{
Name: "#1",
Title: "Founder",
},
Height: 0,
}
tree := &Tree{
Id: id,
Root: &rootNode,
}
return tree
}
// GetRoot will retrieve the Root Node of a tree
func (tree Tree) GetRoot() (*Node, error) {
if tree.Root == nil {
return nil, fmt.Errorf("Tree does not contain a root node")
}
return tree.Root, nil
}
// FindNode will find a node with `id` in the tree in O(n) operations
// by default, `start` node will be the Root node
// it is possible to define the `start` node to speed up operations
func (tree Tree) FindNode(id string, start *Node) (*Node, error) {
if start == nil {
rootNode, err := tree.GetRoot()
if err != nil {
return nil, err
}
start = rootNode
}
if start.ID == id {
return start, nil
}
if start.Children != nil {
for _, child := range start.Children {
foundNode, err := tree.FindNode(id, child)
if err != nil {
return nil, err
}
if foundNode != nil {
return foundNode, nil
}
}
}
return nil, nil
}
// AttachNode will receive two node pointers in a tree,
// and will attach the first one as a subordinate of the foremost
// this will update the entire subtree of the node being attached
func (tree Tree) AttachNode(newNode *Node, parent *Node) error {
if parent == nil || newNode == nil {
return fmt.Errorf("Must provide a new node and parent to attach it to")
}
if parent == newNode {
return fmt.Errorf("It is not possible to attach a Node to itself")
}
foundParentNode, err := tree.FindNode(parent.ID, nil)
if err != nil {
return fmt.Errorf("An error has occurred when searching for parent node on the tree.\nDetails: %s", err.Error())
}
if foundParentNode == nil {
return fmt.Errorf("The parent node does not exist on the tree")
}
root, err := tree.GetRoot()
if err != nil {
return err
}
newNode.RootID = &root.ID
newNode.ParentID = parent.ID
newNode.updateHeight(parent.Height + 1)
parent.Children = append(parent.Children, newNode)
return nil
}
// DetachNode will remove a `node` from its parent
// and will return a pointer to the detached node
func (tree Tree) DetachNode(node *Node) (*Node, error) {
if node == nil {
return nil, fmt.Errorf("Must provide a new node to detach")
}
if node == tree.Root {
return nil, fmt.Errorf("Cannot detach root node from tree. Where would you attach it?")
}
parentNode, err := tree.FindNode(node.ParentID, nil)
if err != nil {
return nil, fmt.Errorf("Could not find parent node to detach on this tree.\nDetails: '%v'", err)
}
parentNode.removeChildren(node)
node.RootID = nil
return node, nil
}
// MoveNode will detach a the subtree of a given `node`
// and then attach it as a descendant of `newParent`
func (tree Tree) MoveNode(node *Node, newParent *Node) error {
if node == nil || newParent == nil {
return fmt.Errorf("Must provide a node to move and parent to attach it to")
}
detachedNode, err := tree.DetachNode(node)
if err != nil {
return fmt.Errorf("Unable to detach node from tree.\nDetails: %s", err.Error())
}
tree.AttachNode(detachedNode, newParent)
if err != nil {
return fmt.Errorf("Unable to attach node to new parent.\nDetails: %s", err.Error())
}
return nil
} | tree/tree.go | 0.754192 | 0.457258 | tree.go | starcoder |
package main
import (
"sort"
. "github.com/9d77v/leetcode/pkg/algorithm/unionfind"
)
/*
题目：水位上升的泳池中游泳
在一个 N x N 的坐标方格 grid 中，每一个方格的值 grid[i][j] 表示在位置 (i,j) 的平台高度。
现在开始下雨了。当时间为 t 时，此时雨水导致水池中任意位置的水位为 t 。你可以从一个平台游向四周相邻的任意一个平台，但是前提是此时水位必须同时淹没这两个平台。假定你可以瞬间移动无限距离，也就是默认在方格内部游动是不耗时的。当然，在你游泳的时候你必须待在坐标方格里面。
你从坐标方格的左上平台 (0，0) 出发。最少耗时多久你才能到达坐标方格的右下平台 (N-1, N-1)？
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/swim-in-rising-water
*/
/*
方法一：二分+bfs
时间复杂度：О(n2logn)
空间复杂度：О(n2)
运行时间：8 ms 内存消耗：6.8MB
*/
func swimInWaterFunc1(grid [][]int) int {
n := len(grid)
if n == 0 {
return 0
}
m := len(grid[0])
if m == 0 {
return 0
}
var bfs func(mid int, visited [][]bool) bool
bfs = func(mid int, visited [][]bool) bool {
q := [][2]int{{0, 0}}
for len(q) > 0 {
p := q[0]
q = q[1:]
for _, d := range directions {
x, y := p[0]+d[0], p[1]+d[1]
if x >= 0 && x < n && y >= 0 && y < m && grid[x][y] <= mid && !visited[x][y] {
q = append(q, [2]int{x, y})
if x == m-1 && y == n-1 {
return true
}
visited[x][y] = true
}
}
}
return false
}
return sort.Search(n*n, func(mid int) bool {
if grid[0][0] > mid {
return false
}
visited := make([][]bool, n)
for i := 0; i < n; i++ {
visited[i] = make([]bool, m)
}
visited[0][0] = true
return bfs(mid, visited)
})
}
func index(i, j, m int) int {
return i*m + j
}
var directions = [4][2]int{{-1, 0}, {0, 1}, {1, 0}, {0, -1}}
/*
方法二：二分+dfs
时间复杂度：О(n2logn)
空间复杂度：О(n2)
运行时间：8 ms 内存消耗：4.7MB
*/
func swimInWaterFunc2(grid [][]int) int {
n := len(grid)
if n == 0 {
return 0
}
m := len(grid[0])
if m == 0 {
return 0
}
var dfs func(mid, i, j int, visited [][]bool) bool
dfs = func(mid, i, j int, visited [][]bool) bool {
visited[i][j] = true
for _, d := range directions {
x, y := i+d[0], j+d[1]
if x >= 0 && x < n && y >= 0 && y < m && grid[x][y] <= mid && !visited[x][y] {
if x == n-1 && y == m-1 {
return true
}
if dfs(mid, x, y, visited) {
return true
}
}
}
return false
}
return sort.Search(n*n, func(mid int) bool {
if grid[0][0] > mid {
return false
}
visited := make([][]bool, n)
for i := 0; i < n; i++ {
visited[i] = make([]bool, m)
}
return dfs(mid, 0, 0, visited)
})
}
/*
方法三：二分+并查集
时间复杂度：О(n2logn)
空间复杂度：О(n2)
运行时间：16 ms 内存消耗：6.6MB
*/
func swimInWaterFunc3(grid [][]int) int {
n := len(grid)
if n == 0 {
return 0
}
m := len(grid[0])
if m == 0 {
return 0
}
var bfs func(mid int) bool
bfs = func(mid int) bool {
uf := NewUnionFind(n * n)
for i := range grid {
for j := range grid[0] {
if grid[i][j] <= mid {
uf.Union(index(i, j, m), index(i, j, m))
if i > 0 && grid[i-1][j] <= mid {
uf.Union(index(i, j, m), index(i-1, j, m))
}
if j > 0 && grid[i][j-1] <= mid {
uf.Union(index(i, j, m), index(i, j-1, m))
}
}
}
}
return uf.IsConnected(0, index(n-1, m-1, m))
}
return sort.Search(n*n, func(mid int) bool {
if grid[0][0] > mid {
return false
}
return bfs(mid)
})
}
/*
方法四：并查集
时间复杂度：О(n2logn)
空间复杂度：О(n2)
运行时间：12 ms 内存消耗：4.2MB
*/
func swimInWaterFunc4(grid [][]int) int {
n := len(grid)
if n == 0 {
return 0
}
m := len(grid[0])
if m == 0 {
return 0
}
data := make([]int, n*n)
for i := 0; i < n; i++ {
for j := 0; j < m; j++ {
data[grid[i][j]] = index(i, j, m)
}
}
uf := NewUnionFind(n * n)
for num, value := range data {
i, j := value/n, value%n
for _, d := range directions {
x, y := i+d[0], j+d[1]
if x >= 0 && x < n && y >= 0 && y < m && grid[x][y] <= num {
uf.Union(value, index(x, y, m))
if uf.IsConnected(0, index(n-1, m-1, m)) {
return num
}
}
}
}
return 0
} | internal/leetcode/778.swim-in-rising-water/main.go | 0.535827 | 0.448004 | main.go | starcoder |
package sqlbuilder
import (
"reflect"
"strconv"
)
type Builder struct {
//The query value bindings
bindings
//The Columns that should be return
columns []string
//The table which the query is targeting
table string
//Update columns
update []interface{}
//Insert columns
insert []string
//Indicates is delete sql.
delete bool
//Indicates if the query return district results.
district bool
//The where constraints for the query.
wheres []*where
//The groupings for the query.
groups []string
//The havings constraints for the query.
havings []*where
//The table joins for the query.
joins []*join
//The orderings for the query.
orders []*order
//The maximum number of records to return.
limit string
//The number of records to skip.
offset string
}
type bindings struct {
selected []string
insert []string
update []string
from []string
join []string
where []string
having []string
order []string
}
//Expression for raw sql
type Expression struct {
Value string
}
type where struct {
column string
operator string
value interface{}
boolean string
}
type join struct {
table string
condition string
joinType string // inner left right
}
type order struct {
column string
direction string
}
//All of the available clause operators.
var operators = []string{"=", "<", ">", "<=", ">=", "<>", "!=", "<=>", "like", "like binary", "not like", "ilike",
"&", "|", "^", "<<", ">>", "rlike", "regexp", "not regexp", "~", "~*", "!~", "!~*", "similar to", "not similar to",
"not ilike", "~~*", "!~~*", "in", "not in",
}
//Is val in array
func in_array(val interface{}, array interface{}) (exists bool, index int) {
exists = false
index = -1
switch reflect.TypeOf(array).Kind() {
case reflect.Slice:
s := reflect.ValueOf(array)
for i := 0; i < s.Len(); i++ {
if reflect.DeepEqual(val, s.Index(i).Interface()) == true {
index = i
exists = true
return
}
}
}
return
}
func (b *Builder) invalidOperator(operator string) bool {
exists, _ := in_array(operator, operators)
return exists
}
func (b *Builder) Select(columns []string) *Builder {
b.columns = columns
return b
}
func (b *Builder) From(table string) *Builder {
b.table = table
return b
}
/*
Where("column", "1")
Where("column", "=","1")
Where("column", "in", []string{"1","2","3"})
Where("column", "=", "1", "or")
Where(map[string]string{column1:"1", column2: "2"})
*/
func (b *Builder) Where(column interface{}, args ...interface{}) *Builder {
switch column.(type) {
case string:
operator := "="
value := ""
booll := "and"
lenArgs := len(args)
if lenArgs == 1 {
value = args[0].(string)
} else if lenArgs >= 2 {
operator = args[0].(string)
if lenArgs >= 3 {
booll = args[2].(string)
}
switch args[1].(type) {
case string:
value = args[1].(string)
case []string:
//支持 where in 操作
if !b.invalidOperator(operator) {
operator = "="
}
condition := &where{column.(string), operator, args[1], booll}
b.wheres = append(b.wheres, condition)
b.bindings.where = append(b.bindings.where, args[1].([]string)...)
goto end
}
}
if !b.invalidOperator(operator) {
operator = "="
}
condition := &where{column.(string), operator, value, booll}
b.wheres = append(b.wheres, condition)
b.bindings.where = append(b.bindings.where, value)
case map[string]string:
return b.addArrayOfWheres(column.(map[string]string), "and")
}
end:
return b
}
func (b *Builder) addArrayOfWheres(wheres map[string]string, boolean string) *Builder {
for k, v := range wheres {
condition := &where{k, "=", v, boolean}
b.wheres = append(b.wheres, condition)
b.bindings.where = append(b.bindings.where, v)
}
return b
}
/*
Join("tableB", "tableB.id = tableA.bId")
*/
func (b *Builder) Join(table string, condition string, args ...string) *Builder {
joinType := "inner"
lenArgs := len(args)
if lenArgs > 0 {
joinType = args[0]
}
j := &join{table, condition, joinType}
b.joins = append(b.joins, j)
return b
}
func (b *Builder) LeftJoin(table string, condition string) *Builder {
return b.Join(table, condition, "left")
}
func (b *Builder) RightJoin(table string, condition string) *Builder {
return b.Join(table, condition, "right")
}
func (b *Builder) GroupBy(group interface{}) *Builder {
switch group.(type) {
case []string:
b.groups = append(b.groups, group.([]string)...)
case string:
b.groups = append(b.groups, group.(string))
}
return b
}
/*
Having("column", "1")
Having("column", "=","1")
Having("column", "=", "1", "or")
Having(map[string]string{column1:"1", column2: "2"})
*/
func (b *Builder) Having(column interface{}, operator string, args ...string) *Builder {
switch column.(type) {
case string:
value := ""
booll := "and"
lenArgs := len(args)
if lenArgs == 0 {
value = operator
} else if lenArgs >= 1 {
value = args[0]
} else if lenArgs >= 2 {
booll = args[1]
}
if !b.invalidOperator(operator) {
operator = "="
}
condition := &where{column.(string), operator, value, booll}
b.havings = append(b.havings, condition)
b.bindings.having = append(b.bindings.having, value)
case map[string]string:
return b.addArrayOfHavings(column.(map[string]string), "and")
}
return b
}
func (b *Builder) addArrayOfHavings(wheres map[string]string, boolean string) *Builder {
for k, v := range wheres {
condition := &where{k, "=", v, boolean}
b.havings = append(b.wheres, condition)
b.bindings.having = append(b.bindings.having, v)
}
return b
}
func (b *Builder) OrderBy(column string, direction string) *Builder {
b.orders = append(b.orders, &order{column, direction})
return b
}
func (b *Builder) OrderByAsc(column string) *Builder {
return b.OrderBy(column, "asc")
}
func (b *Builder) OrderByDesc(column string) *Builder {
return b.OrderBy(column, "desc")
}
func (b *Builder) Offset(offset interface{}) *Builder {
switch offset.(type) {
case string:
b.offset = offset.(string)
case int:
b.offset = strconv.Itoa(offset.(int))
}
return b
}
func (b *Builder) Limit(limit interface{}) *Builder {
switch limit.(type) {
case string:
b.limit = limit.(string)
case int:
b.limit = strconv.Itoa(limit.(int))
}
return b
}
func (b *Builder) Insert(table string, info map[string]string) *Builder {
b.table = table
for column, value := range info {
b.insert = append(b.insert, column)
b.bindings.insert = append(b.bindings.insert, value)
}
return b
}
func (b *Builder) Update(table string, info map[string]interface{}) *Builder {
b.table = table
for column, value := range info {
switch value.(type) {
case string:
b.update = append(b.update, column)
b.bindings.update = append(b.bindings.update, value.(string))
case *Expression:
//表达式： 如 a = a + 1
b.update = append(b.update, value)
}
}
return b
}
func (b *Builder) Delete(table string) *Builder {
b.table = table
b.delete = true
return b
}
func (b *Builder) ToSql() (sql string, bindings []string) {
if b.delete {
return CompileDelete(b)
} else if len(b.insert) > 0 {
return CompileInsert(b)
} else if len(b.update) > 0 {
return CompileUpdate(b)
} else {
return CompileSelect(b)
}
} | builder.go | 0.626238 | 0.543166 | builder.go | starcoder |
package raster
import (
"fmt"
"strings"
)
type Raster struct {
Data []float64
Xsize int
Ysize int
Size int
CellXSize float64
CellYSize float64
Nodata float64
}
type Cell struct {
Value *float64
Xindex int
Yindex int
}
type Direction int
const (
None Direction = 0
Right Direction = 1
BottomRight Direction = 2
Bottom Direction = 4
BottomLeft Direction = 8
Left Direction = 16
TopLeft Direction = 32
Top Direction = 64
TopRight Direction = 128
)
func (d Direction) IsDiagonal() bool {
if d == BottomLeft || d == BottomRight || d == TopLeft || d == TopRight {
return true
} else {
return false
}
}
func (c *Cell) GetValue() float64 {
return *c.Value
}
func (c *Cell) SetValue(val float64) {
*c.Value = val
}
func (c *Cell) EdgeDirection(r *Raster) Direction {
if c.Yindex == 0 && c.Xindex == 0 {
return TopLeft
} else if c.Yindex == 0 && c.Xindex == r.Xsize-1 {
return TopRight
} else if c.Xindex == 0 && c.Yindex == r.Ysize-1 {
return BottomLeft
} else if c.Xindex == r.Xsize-1 && c.Yindex == r.Ysize-1 {
return BottomRight
} else if c.Yindex == 0 {
return Top
} else if c.Yindex == r.Ysize-1 {
return Bottom
} else if c.Xindex == 0 {
return Left
} else if c.Xindex == r.Xsize-1 {
return Right
} else {
return None
}
}
func (c *Cell) RelativeDirection(neighbor *Cell) Direction {
currentX := c.Xindex
currentY := c.Yindex
neighborX := neighbor.Xindex
neighborY := neighbor.Yindex
if neighborY == currentY-1 && neighborX == currentX-1 {
return TopLeft
} else if neighborY == currentY-1 && neighborX == currentX+1 {
return TopRight
} else if neighborY == currentY+1 && neighborX == currentX-1 {
return BottomLeft
} else if neighborY == currentY+1 && neighborX == currentX+1 {
return BottomRight
} else if neighborY == currentY-1 && neighborX == currentX {
return Top
} else if neighborY == currentY+1 && neighborX == currentX {
return Bottom
} else if neighborY == currentY && neighborX == currentX-1 {
return Left
} else if neighborY == currentY && neighborX == currentX+1 {
return Right
} else {
return None
}
}
func NewRaster(xsize, ysize int, cellXSize, cellYSize, noData float64) *Raster {
r := Raster{Data: make([]float64, xsize*ysize), Xsize: xsize, Ysize: ysize,
CellXSize: cellXSize, CellYSize: cellYSize, Size: xsize * ysize,
Nodata: noData}
return &r
}
func NewRasterWithRaster(r *Raster) *Raster {
cr := NewRaster(r.Xsize, r.Ysize, r.CellXSize, r.CellYSize, r.Nodata)
return cr
}
func CopyRaster(r *Raster) *Raster {
cr := Raster{Data: make([]float64, r.Xsize*r.Ysize), Xsize: r.Xsize,
Ysize: r.Ysize, CellXSize: r.CellXSize, CellYSize: r.CellYSize,
Size: r.Xsize * r.Ysize, Nodata: r.Nodata}
copy(cr.Data, r.Data)
return &cr
}
func (r *Raster) Get(x, y int) float64 {
return r.Data[y*r.Xsize+x]
}
func (r *Raster) GetWithCell(c *Cell) float64 {
return r.Data[c.Yindex*r.Xsize+c.Xindex]
}
func (r *Raster) Set(x, y int, val float64) {
r.Data[y*r.Xsize+x] = val
}
func (r *Raster) SetWithCell(c *Cell, val float64) {
r.Data[c.Yindex*r.Xsize+c.Xindex] = val
}
func (r *Raster) IsInRegion(x, y int) bool {
if (x >= 0 && x < r.Xsize) && (y >= 0 && y < r.Ysize) {
return true
} else {
return false
}
}
func (r *Raster) String() string {
var sb strings.Builder
sb.WriteString(fmt.Sprintf("Xsize\t\t\t%d\n", r.Xsize))
sb.WriteString(fmt.Sprintf("Ysize\t\t\t%d\n", r.Ysize))
sb.WriteString(fmt.Sprintf("Nodata\t\t\t%f\n", r.Nodata))
sb.WriteString("\n")
for y := 0; y < r.Ysize; y++ {
for x := 0; x < r.Xsize; x++ {
sb.WriteString(fmt.Sprintf("%f", r.Get(x, y)))
if x != r.Xsize-1 {
sb.WriteString("\t")
}
}
if y != r.Ysize-1 {
sb.WriteString("\n")
}
}
return sb.String()
}
type Bitmap struct {
Data []bool
Xsize int
Ysize int
Size int
}
func NewBitmap(xsize, ysize int) *Bitmap {
bm := Bitmap{Data: make([]bool, xsize*ysize), Xsize: xsize, Ysize: ysize,
Size: xsize * ysize}
return &bm
}
func NewBitmapWithRaster(r *Raster) *Bitmap {
bm := NewBitmap(r.Xsize, r.Ysize)
return bm
}
func (bm *Bitmap) Get(x, y int) bool {
return bm.Data[y*bm.Xsize+x]
}
func (bm *Bitmap) GetWithCell(c *Cell) bool {
return bm.Data[c.Yindex*bm.Xsize+c.Xindex]
}
func (bm *Bitmap) Set(x, y int) {
bm.Data[y*bm.Xsize+x] = true
}
func (bm *Bitmap) SetWithCell(c *Cell) {
bm.Data[c.Yindex*bm.Xsize+c.Xindex] = true
}
func (bm *Bitmap) Unset(x, y int) {
bm.Data[y*bm.Xsize+x] = false
}
func (bm *Bitmap) UnsetWithCell(c *Cell) {
bm.Data[c.Yindex*bm.Xsize+c.Xindex] = false
}
func (bm *Bitmap) IsInRegion(x, y int) bool {
if (x >= 0 && x < bm.Xsize) && (y >= 0 && y < bm.Ysize) {
return true
} else {
return false
}
}
func (bm *Bitmap) String() string {
var sb strings.Builder
sb.WriteString(fmt.Sprintf("Xsize\t\t\t%d\n", bm.Xsize))
sb.WriteString(fmt.Sprintf("Ysize\t\t\t%d\n", bm.Ysize))
sb.WriteString("\n")
for y := 0; y < bm.Ysize; y++ {
for x := 0; x < bm.Xsize; x++ {
sb.WriteString(fmt.Sprintf("%t", bm.Get(x, y)))
if x != bm.Xsize-1 {
sb.WriteString("\t")
}
}
if y != bm.Ysize-1 {
sb.WriteString("\n")
}
}
return sb.String()
}
type Intmap struct {
Data []int
Xsize int
Ysize int
Size int
}
func NewIntmap(xsize, ysize int) *Intmap {
bm := Intmap{Data: make([]int, xsize*ysize), Xsize: xsize, Ysize: ysize,
Size: xsize * ysize}
return &bm
}
func NewIntmapWithRaster(r *Raster) *Intmap {
bm := NewIntmap(r.Xsize, r.Ysize)
return bm
}
func (bm *Intmap) Get(x, y int) int {
return bm.Data[y*bm.Xsize+x]
}
func (bm *Intmap) GetWithCell(c *Cell) int {
return bm.Data[c.Yindex*bm.Xsize+c.Xindex]
}
func (bm *Intmap) Set(x, y, val int) {
bm.Data[y*bm.Xsize+x] = val
}
func (bm *Intmap) SetWithCell(c *Cell, val int) {
bm.Data[c.Yindex*bm.Xsize+c.Xindex] = val
}
func (bm *Intmap) IsInRegion(x, y int) bool {
if (x >= 0 && x < bm.Xsize) && (y >= 0 && y < bm.Ysize) {
return true
} else {
return false
}
}
func (bm *Intmap) String() string {
var sb strings.Builder
sb.WriteString(fmt.Sprintf("Xsize\t\t\t%d\n", bm.Xsize))
sb.WriteString(fmt.Sprintf("Ysize\t\t\t%d\n", bm.Ysize))
sb.WriteString("\n")
for y := 0; y < bm.Ysize; y++ {
for x := 0; x < bm.Xsize; x++ {
sb.WriteString(fmt.Sprintf("%d", bm.Get(x, y)))
if x != bm.Xsize-1 {
sb.WriteString("\t")
}
}
if y != bm.Ysize-1 {
sb.WriteString("\n")
}
}
return sb.String()
} | raster/raster.go | 0.66356 | 0.464659 | raster.go | starcoder |
package mock
var example1DayForecast string = `
{
"DailyForecasts": [
{
"AirAndPollen": [
{
"Category": "Good",
"CategoryValue": 1,
"Name": "AirQuality",
"Type": "Ozone",
"Value": 38
},
{
"Category": "Low",
"CategoryValue": 1,
"Name": "Grass",
"Value": 0
},
{
"Category": "Low",
"CategoryValue": 1,
"Name": "Mold",
"Value": 0
},
{
"Category": "Low",
"CategoryValue": 1,
"Name": "Ragweed",
"Value": 0
},
{
"Category": "Low",
"CategoryValue": 1,
"Name": "Tree",
"Value": 0
},
{
"Category": "Moderate",
"CategoryValue": 2,
"Name": "UVIndex",
"Value": 3
}
],
"Date": "2020-04-28T07:00:00+03:00",
"Day": {
"CloudCover": 83,
"HasPrecipitation": false,
"HoursOfIce": 0,
"HoursOfPrecipitation": 0,
"HoursOfRain": 0,
"HoursOfSnow": 0,
"Ice": {
"Unit": "mm",
"UnitType": 3,
"Value": 0
},
"IceProbability": 0,
"Icon": 6,
"IconPhrase": "Mostly cloudy",
"LongPhrase": "Some sun, then turning cloudy and chilly",
"PrecipitationProbability": 25,
"Rain": {
"Unit": "mm",
"UnitType": 3,
"Value": 0
},
"RainProbability": 25,
"ShortPhrase": "Turning cloudy and chilly",
"Snow": {
"Unit": "cm",
"UnitType": 4,
"Value": 0
},
"SnowProbability": 0,
"ThunderstormProbability": 0,
"TotalLiquid": {
"Unit": "mm",
"UnitType": 3,
"Value": 0
},
"Wind": {
"Direction": {
"Degrees": 120,
"English": "ESE",
"Localized": "ESE"
},
"Speed": {
"Unit": "km/h",
"UnitType": 7,
"Value": 14.8
}
},
"WindGust": {
"Direction": {
"Degrees": 150,
"English": "SSE",
"Localized": "SSE"
},
"Speed": {
"Unit": "km/h",
"UnitType": 7,
"Value": 25.9
}
}
},
"DegreeDaySummary": {
"Cooling": {
"Unit": "C",
"UnitType": 17,
"Value": 0
},
"Heating": {
"Unit": "C",
"UnitType": 17,
"Value": 14
}
},
"EpochDate": 1588046400,
"HoursOfSun": 4.5,
"Link": "http://www.accuweather.com/en/fi/niittykumpu/133030/daily-weather-forecast/133030?day=1&unit=c&lang=en-us",
"MobileLink": "http://m.accuweather.com/en/fi/niittykumpu/133030/daily-weather-forecast/133030?day=1&unit=c&lang=en-us",
"Moon": {
"Age": 5,
"EpochRise": 1588050060,
"EpochSet": 1588119780,
"Phase": "WaxingCrescent",
"Rise": "2020-04-28T08:01:00+03:00",
"Set": "2020-04-29T03:23:00+03:00"
},
"Night": {
"CloudCover": 45,
"HasPrecipitation": true,
"HoursOfIce": 0,
"HoursOfPrecipitation": 0.5,
"HoursOfRain": 0.5,
"HoursOfSnow": 0,
"Ice": {
"Unit": "mm",
"UnitType": 3,
"Value": 0
},
"IceProbability": 0,
"Icon": 35,
"IconPhrase": "Partly cloudy",
"LongPhrase": "A shower in places this evening; otherwise, partly cloudy",
"PrecipitationIntensity": "Light",
"PrecipitationProbability": 40,
"PrecipitationType": "Rain",
"Rain": {
"Unit": "mm",
"UnitType": 3,
"Value": 0.2
},
"RainProbability": 40,
"ShortPhrase": "A shower early; patchy clouds",
"Snow": {
"Unit": "cm",
"UnitType": 4,
"Value": 0
},
"SnowProbability": 12,
"ThunderstormProbability": 20,
"TotalLiquid": {
"Unit": "mm",
"UnitType": 3,
"Value": 0.2
},
"Wind": {
"Direction": {
"Degrees": 29,
"English": "NNE",
"Localized": "NNE"
},
"Speed": {
"Unit": "km/h",
"UnitType": 7,
"Value": 13
}
},
"WindGust": {
"Direction": {
"Degrees": 109,
"English": "ESE",
"Localized": "ESE"
},
"Speed": {
"Unit": "km/h",
"UnitType": 7,
"Value": 20.4
}
}
},
"RealFeelTemperature": {
"Maximum": {
"Unit": "C",
"UnitType": 17,
"Value": 7.4
},
"Minimum": {
"Unit": "C",
"UnitType": 17,
"Value": -2.2
}
},
"RealFeelTemperatureShade": {
"Maximum": {
"Unit": "C",
"UnitType": 17,
"Value": 6.8
},
"Minimum": {
"Unit": "C",
"UnitType": 17,
"Value": -2.2
}
},
"Sources": [
"AccuWeather"
],
"Sun": {
"EpochRise": 1588040640,
"EpochSet": 1588097580,
"Rise": "2020-04-28T05:24:00+03:00",
"Set": "2020-04-28T21:13:00+03:00"
},
"Temperature": {
"Maximum": {
"Unit": "C",
"UnitType": 17,
"Value": 7
},
"Minimum": {
"Unit": "C",
"UnitType": 17,
"Value": 0.6
}
}
}
],
"Headline": {
"Category": "rain",
"EffectiveDate": "2020-04-28T20:00:00+03:00",
"EffectiveEpochDate": 1588093200,
"EndDate": "2020-04-29T02:00:00+03:00",
"EndEpochDate": 1588114800,
"Link": "http://www.accuweather.com/en/fi/niittykumpu/133030/daily-weather-forecast/133030?unit=c&lang=en-us",
"MobileLink": "http://m.accuweather.com/en/fi/niittykumpu/133030/extended-weather-forecast/133030?unit=c&lang=en-us",
"Severity": 5,
"Text": "Expect showers Tuesday evening"
}
}
` | mock/examples_day_forecast.go | 0.687105 | 0.59355 | examples_day_forecast.go | starcoder |
Package webauthn provides server-side registration and authentication for clients
using FIDO2 keys, FIDO U2F keys, tpm, etc. and is decoupled from `net/http` for
easy integration with existing projects.
It's modular so projects only import what is needed. Five attestation packages are
available: fidou2f, androidkeystore, androidsafetynet, packed, and tpm.
It doesn't import unreliable packages. It uses fxamacker/cbor because it doesn't
crash and it's the most well-tested CBOR library available (v1.5 has 375+ tests
and passed 3+ billion execs in coverage-guided fuzzing).
A demo webapp (https://www.github.com/fxamacker/webauthn-demo) shows how to use
this package with a security token like the YubiKey.
*/
package webauthn
import (
"bytes"
"crypto/rand"
"crypto/sha256"
"encoding/json"
"errors"
"fmt"
"io"
"strconv"
)
// User represents user data for which the Relying Party requests attestation or assertion.
type User struct {
ID []byte
Name string
Icon string
DisplayName string
CredentialIDs [][]byte
}
// AttestationExpectedData represents data needed to verify attestations.
type AttestationExpectedData struct {
Origin string
RPID string
CredentialAlgs []int
Challenge string
UserVerification UserVerificationRequirement
}
// AssertionExpectedData represents data needed to verify assertions.
type AssertionExpectedData struct {
Origin string
RPID string
Challenge string
UserVerification UserVerificationRequirement
UserID []byte
UserCredentialIDs [][]byte
PrevCounter uint32
Credential *Credential
}
// NewAttestationOptions returns a PublicKeyCredentialCreationOptions from config and user.
func NewAttestationOptions(config *Config, user *User) (*PublicKeyCredentialCreationOptions, error) {
if len(user.Name) == 0 {
return nil, errors.New("user name is required")
}
if len(user.ID) == 0 {
return nil, errors.New("user id is required")
}
if len(user.DisplayName) == 0 {
return nil, errors.New("user display name is required")
}
challenge := make([]byte, config.ChallengeLength)
if n, err := rand.Read(challenge); err != nil {
return nil, errors.New("failed to generate challenge: " + err.Error())
} else if n != config.ChallengeLength {
return nil, errors.New("failed to generate " + strconv.Itoa(config.ChallengeLength) + " bytes of challenge")
}
var excludeCredentials []PublicKeyCredentialDescriptor
for _, id := range user.CredentialIDs {
excludeCredentials = append(excludeCredentials, PublicKeyCredentialDescriptor{Type: PublicKeyCredentialTypePublicKey, ID: id})
}
var credentialParams []PublicKeyCredentialParameters
for _, alg := range config.CredentialAlgs {
credentialParams = append(credentialParams, PublicKeyCredentialParameters{PublicKeyCredentialTypePublicKey, alg})
}
options := &PublicKeyCredentialCreationOptions{
RP: PublicKeyCredentialRpEntity{
Name: config.RPName,
Icon: config.RPIcon,
ID: config.RPID,
},
User: PublicKeyCredentialUserEntity{
Name: user.Name,
Icon: user.Icon,
ID: user.ID,
DisplayName: user.DisplayName,
},
Challenge: challenge,
PubKeyCredParams: credentialParams,
Timeout: config.Timeout,
ExcludeCredentials: excludeCredentials,
AuthenticatorSelection: AuthenticatorSelectionCriteria{
AuthenticatorAttachment: config.AuthenticatorAttachment,
RequireResidentKey: config.ResidentKey == ResidentKeyRequired,
ResidentKey: config.ResidentKey,
UserVerification: config.UserVerification,
},
Attestation: config.Attestation,
}
return options, nil
}
// ParseAttestation parses credential attestation and returns PublicKeyCredentialAttestation.
func ParseAttestation(r io.Reader) (*PublicKeyCredentialAttestation, error) {
var credentialAttestation PublicKeyCredentialAttestation
if err := json.NewDecoder(r).Decode(&credentialAttestation); err != nil {
return nil, err
}
return &credentialAttestation, nil
}
// VerifyAttestation verifies attestation and returns attestation type, trust path, or error,
// as defined in http://w3c.github.io/webauthn/#sctn-registering-a-new-credential
func VerifyAttestation(credentialAttestation *PublicKeyCredentialAttestation, expected *AttestationExpectedData) (attType AttestationType, trustPath interface{}, err error) {
// Verify that the value of C.type is webauthn.create.
if credentialAttestation.ClientData.Type != "webauthn.create" {
err = &VerificationError{Type: "attestation", Field: "client data type", Msg: "expected \"webauthn.create\", got \"" + credentialAttestation.ClientData.Type + "\""}
return
}
// Verify that the value of C.challenge equals the base64url encoding of options.challenge.
if credentialAttestation.ClientData.Challenge != expected.Challenge {
err = &VerificationError{Type: "attestation", Field: "client data challenge", Msg: "client data challenge does not match expected challenge"}
return
}
// Verify that the value of C.origin matches the Relying Party's origin.
if credentialAttestation.ClientData.Origin != expected.Origin {
err = &VerificationError{Type: "attestation", Field: "client data origin", Msg: "expected \"" + expected.Origin + "\", got \"" + credentialAttestation.ClientData.Origin + "\""}
return
}
// Verify that authData's credential id matches the credential's raw id.
if !bytes.Equal(credentialAttestation.RawID, credentialAttestation.AuthnData.CredentialID) {
err = &VerificationError{Type: "attestation", Field: "credential ID", Msg: "attestation's raw ID does not match credential ID"}
return
}
// Verify that the rpIdHash in authData is the SHA-256 hash of the RP ID expected by the Relying Party.
computedRPIDHash := sha256.Sum256([]byte(expected.RPID))
if !bytes.Equal(credentialAttestation.AuthnData.RPIDHash, computedRPIDHash[:]) {
err = &VerificationError{Type: "attestation", Field: "rp ID", Msg: "authenticator data's rp ID hash does not match computed rp ID hash"}
return
}
// Verify that the User Present bit of the flags in authData is set.
if !credentialAttestation.AuthnData.UserPresent {
err = &VerificationError{Type: "attestation", Field: "user present", Msg: "user wasn't present"}
return
}
// If user verification is required for this registration, verify that the User Verified bit of the flags in authData is set.
if expected.UserVerification == UserVerificationRequired && !credentialAttestation.AuthnData.UserVerified {
err = &VerificationError{Type: "attestation", Field: "user verification", Msg: "user didn't verify"}
return
}
// Verify that the "alg" parameter in the credential public key in authData matches the alg
// attribute of one of the items in options.pubKeyCredParams.
foundAlg := false
for _, alg := range expected.CredentialAlgs {
if alg == credentialAttestation.AuthnData.Credential.COSEAlgorithm {
foundAlg = true
break
}
}
if !foundAlg {
err = &VerificationError{Type: "attestation", Field: "credential algorithm", Msg: "credential algorithm is not among options.pubKeyCredParams."}
return
}
// todo: Verify that the value of C.tokenBinding.status matches the state of Token Binding for
// the TLS connection over which the assertion was obtained. If Token Binding was used on that
// TLS connection, also verify that C.tokenBinding.id matches the base64url encoding of the
// Token Binding ID for the connection.
// todo: Verify that the values of the client extension outputs in clientExtensionResults and
// the authenticator extension outputs in the extensions in authData are as expected.
return credentialAttestation.VerifyAttestationStatement()
}
// NewAssertionOptions returns a PublicKeyCredentialRequestOptions from config and user.
func NewAssertionOptions(config *Config, user *User) (*PublicKeyCredentialRequestOptions, error) {
challenge := make([]byte, config.ChallengeLength)
if n, err := rand.Read(challenge); err != nil {
return nil, errors.New("failed to generate challenge: " + err.Error())
} else if n != config.ChallengeLength {
return nil, errors.New("failed to generate " + strconv.Itoa(config.ChallengeLength) + " bytes of challenge")
}
var allowCredentials []PublicKeyCredentialDescriptor
for _, id := range user.CredentialIDs {
allowCredentials = append(allowCredentials, PublicKeyCredentialDescriptor{Type: PublicKeyCredentialTypePublicKey, ID: id})
}
options := &PublicKeyCredentialRequestOptions{
Challenge: challenge,
Timeout: config.Timeout,
RPID: config.RPID,
AllowCredentials: allowCredentials,
UserVerification: config.UserVerification,
}
return options, nil
}
// ParseAssertion parses credential assertion and returns PublicKeyCredentialAssertion.
func ParseAssertion(r io.Reader) (*PublicKeyCredentialAssertion, error) {
var credentialAssertion PublicKeyCredentialAssertion
if err := json.NewDecoder(r).Decode(&credentialAssertion); err != nil {
return nil, err
}
return &credentialAssertion, nil
}
// VerifyAssertion verifies assertion and returns error, as defined in http://w3c.github.io/webauthn/#sctn-verifying-assertion
func VerifyAssertion(credentialAssertion *PublicKeyCredentialAssertion, expected *AssertionExpectedData) error {
// Verify that credential.id identifies one of the public key credentials listed in options.allowCredentials.
foundCredentialID := false
for _, id := range expected.UserCredentialIDs {
if bytes.Equal(id, credentialAssertion.RawID) {
foundCredentialID = true
break
}
}
if len(expected.UserCredentialIDs) > 0 && !foundCredentialID {
return &VerificationError{Type: "assertion", Field: "credential ID", Msg: "credential ID is not allowed"}
}
// Verify that userHandle also is the owner of the public key credential.
if len(credentialAssertion.UserHandle) > 0 {
if !bytes.Equal(credentialAssertion.UserHandle, expected.UserID) {
return &VerificationError{Type: "assertion", Field: "user handle", Msg: fmt.Sprintf("expected %02x, got %02x", expected.UserID, credentialAssertion.UserHandle)}
}
}
// Verify that the value of C.type is the string webauthn.get.
if credentialAssertion.ClientData.Type != "webauthn.get" {
return &VerificationError{Type: "assertion", Field: "client data type", Msg: "expected \"webauthn.get\", got \"" + credentialAssertion.ClientData.Type + "\""}
}
// Verify that the value of C.challenge equals the base64url encoding of options.challenge.
if credentialAssertion.ClientData.Challenge != expected.Challenge {
return &VerificationError{Type: "assertion", Field: "client data challenge", Msg: "client data challenge does not match expected challenge"}
}
// Verify that the value of C.origin matches the Relying Party's origin.
if credentialAssertion.ClientData.Origin != expected.Origin {
return &VerificationError{Type: "assertion", Field: "client data origin", Msg: "expected \"" + expected.Origin + "\", got \"" + credentialAssertion.ClientData.Origin + "\""}
}
// Verify that the rpIdHash in authData is the SHA-256 hash of the RP ID expected by the Relying Party.
computedRPIDHash := sha256.Sum256([]byte(expected.RPID))
if !bytes.Equal(credentialAssertion.AuthnData.RPIDHash, computedRPIDHash[:]) {
return &VerificationError{Type: "assertion", Field: "rp ID", Msg: "authenticator data's rp ID hash does not match computed rp ID hash"}
}
// Verify that the User Present bit of the flags in authData is set.
if !credentialAssertion.AuthnData.UserPresent {
return &VerificationError{Type: "assertion", Field: "user present", Msg: "user wasn't present"}
}
// If user verification is required for this assertion, verify that the User Verified bit of the flags in authData is set.
if expected.UserVerification == UserVerificationRequired && !credentialAssertion.AuthnData.UserVerified {
return &VerificationError{Type: "assertion", Field: "user verification", Msg: "user didn't verify"}
}
// Using credentialPublicKey, verify that sig is a valid signature over the binary concatenation of authData and hash.
if err := credentialAssertion.verifySignature(expected.Credential); err != nil {
return err
}
// Verify that authData.signCount does not roll back.
if credentialAssertion.AuthnData.Counter != 0 || expected.PrevCounter != 0 {
if credentialAssertion.AuthnData.Counter <= expected.PrevCounter {
return &VerificationError{Type: "assertion", Field: "counter", Msg: "cloned authenticator is detected"}
}
}
// todo: Verify that the value of C.tokenBinding.status matches the state of Token Binding for
// the TLS connection over which the attestation was obtained. If Token Binding was used on
// that TLS connection, also verify that C.tokenBinding.id matches the base64url encoding of
// the Token Binding ID for the connection.
// todo: Verify that the values of the client extension outputs in clientExtensionResults and
// the authenticator extension outputs in the extensions in authData are as expected.
return nil
} | webauthn.go | 0.659844 | 0.407216 | webauthn.go | starcoder |
package lit
import (
"bytes"
"fmt"
"reflect"
"strconv"
"xelf.org/xelf/ast"
"xelf.org/xelf/bfr"
"xelf.org/xelf/knd"
"xelf.org/xelf/typ"
)
type proxy struct {
Reg *Reg
typ typ.Type
val reflect.Value
}
func newProxy(reg *Reg, t typ.Type, ptr reflect.Value) proxy {
x := proxy{reg, t, ptr}
if x.isptr() {
x.typ = typ.Opt(t)
}
return x
}
func (x *proxy) Nil() bool {
switch x.val.Type().Elem().Kind() {
case reflect.Interface, reflect.Ptr, reflect.Map, reflect.Slice:
return x.val.Elem().IsNil()
}
return false
}
func (x *proxy) Type() typ.Type { return x.typ }
func (x *proxy) Ptr() interface{} { return x.val.Interface() }
func (x *proxy) Reflect() reflect.Value { return x.val.Elem() }
func (x *proxy) new() reflect.Value { return reflect.New(x.val.Type().Elem()) }
func (x *proxy) with(ptr reflect.Value) proxy { return newProxy(x.Reg, x.typ, ptr) }
func (x *proxy) WithReg(reg *Reg) { x.Reg = reg }
func (x *proxy) unmarshal(b []byte, mut Mut) error {
return ReadIntoMut(x.Reg, bytes.NewReader(b), "", mut)
}
func (x *proxy) isptr() bool { return x.val.Type().Elem().Kind() == reflect.Ptr }
func (x *proxy) setNull() error {
if x.isptr() {
val := reflect.Zero(x.val.Type().Elem())
x.val.Elem().Set(val)
} else {
x.val.Elem().Set(reflect.Zero(x.val.Type().Elem()))
}
return nil
}
func (x *proxy) elem() reflect.Value {
e := x.val.Elem()
if !x.isptr() {
if e.Kind() == reflect.Map && e.IsNil() {
e.Set(reflect.MakeMap(e.Type()))
}
return e
}
if !e.IsNil() {
return e.Elem()
}
e = reflect.New(e.Type().Elem())
if e.Kind() == reflect.Map {
e.Set(reflect.MakeMap(e.Type()))
}
x.val.Elem().Set(e)
return e.Elem()
}
type IntPrx struct{ proxy }
func (x *IntPrx) NewWith(v reflect.Value) (Mut, error) { return &IntPrx{x.with(v)}, nil }
func (x *IntPrx) New() (Mut, error) { return x.NewWith(x.new()) }
func (x *IntPrx) Zero() bool { return x.Nil() || x.value() == 0 }
func (x *IntPrx) Value() Val {
if x.Nil() {
return Null{}
}
return Int(x.value())
}
func (x *IntPrx) Parse(a ast.Ast) error {
if isNull(a) {
return x.setNull()
}
if a.Kind != knd.Int {
return ast.ErrExpect(a, knd.Int)
}
n, err := strconv.ParseInt(a.Raw, 10, 64)
if err != nil {
return err
}
x.elem().SetInt(n)
return nil
}
func (x *IntPrx) Assign(v Val) error {
if v == nil || v.Nil() {
return x.setNull()
}
n, err := ToInt(v)
if err != nil {
return err
}
switch e := x.elem(); e.Kind() {
case reflect.Int64, reflect.Int, reflect.Int32, reflect.Int16:
e.SetInt(int64(n))
case reflect.Uint64, reflect.Uint, reflect.Uint32, reflect.Uint16:
e.SetUint(uint64(n))
default:
return fmt.Errorf("unexpected int proxy target %s", e.Type())
}
return nil
}
func (x *IntPrx) value() int64 {
switch e := x.elem(); e.Kind() {
case reflect.Int64, reflect.Int, reflect.Int32:
return e.Int()
case reflect.Uint64, reflect.Uint, reflect.Uint32:
return int64(e.Uint())
default:
panic(fmt.Errorf("unexpected int proxy target %s", e.Type()))
}
}
func (x *IntPrx) String() string {
if x.Nil() {
return "null"
}
return fmt.Sprintf("%d", x.value())
}
func (x *IntPrx) MarshalJSON() ([]byte, error) { return []byte(x.String()), nil }
func (x *IntPrx) UnmarshalJSON(b []byte) error { return x.unmarshal(b, x) }
func (x *IntPrx) Print(p *bfr.P) error { return p.Fmt(x.String()) }
type RealPrx struct{ proxy }
func (x *RealPrx) NewWith(v reflect.Value) (Mut, error) { return &RealPrx{x.with(v)}, nil }
func (x *RealPrx) New() (Mut, error) { return x.NewWith(x.new()) }
func (x *RealPrx) Zero() bool { return x.Nil() || x.value() == 0 }
func (x *RealPrx) Value() Val {
if x.Nil() {
return Null{}
}
return Real(x.value())
}
func (x *RealPrx) Parse(a ast.Ast) error {
if isNull(a) {
return x.setNull()
}
if a.Kind != knd.Real && a.Kind != knd.Int {
return ast.ErrExpect(a, knd.Num)
}
n, err := strconv.ParseFloat(a.Raw, 64)
if err != nil {
return err
}
x.elem().SetFloat(n)
return nil
}
func (x *RealPrx) Assign(v Val) error {
if v == nil || v.Nil() {
return x.setNull()
}
n, err := ToReal(v)
if err != nil {
return err
}
switch e := x.elem(); e.Kind() {
case reflect.Float64, reflect.Float32:
e.SetFloat(float64(n))
default:
return fmt.Errorf("unexpected real proxy target %s", e.Type())
}
return nil
}
func (x *RealPrx) value() float64 {
switch e := x.elem(); e.Kind() {
case reflect.Float64, reflect.Float32:
return e.Float()
default:
panic(fmt.Errorf("unexpected real proxy target %s", e.Type()))
}
}
func (x *RealPrx) String() string {
if x.Nil() {
return "null"
}
return fmt.Sprintf("%g", x.value())
}
func (x *RealPrx) MarshalJSON() ([]byte, error) { return []byte(x.String()), nil }
func (x *RealPrx) UnmarshalJSON(b []byte) error { return x.unmarshal(b, x) }
func (x *RealPrx) Print(p *bfr.P) error { return p.Fmt(x.String()) } | lit/prx.go | 0.589244 | 0.458227 | prx.go | starcoder |
package pager
// This package provides mapping functions to work with slices of uint
// types. It allows the getting, setting and transforming of various
// uint types such as uint, uint16, uint32 and uint64. Right now, this
// set of functions uses the LittleEndian encoding format, but future
// versions of this will have support for both the LittleEndian and
// BitEndian byte order.
// BinMapU16Fn is the mapping function signature for an uint16
type BinMapU16Fn = func(n uint16) *uint16
// IncrU16 returns a mapping function that increments the underlying
// uint16 using the amount provided by `by`, and returns the mapping
// indicating that the mapping changes should be encoded to the
// underlying slice (because it does not return a nil value.)
func IncrU16(by uint16) BinMapU16Fn {
return func(n uint16) *uint16 {
n += by
return &n
}
}
// DecrU16 returns a mapping function that decrements the underlying
// uint16 using the amount provided by `by`, and returns the mapping
// indicating that the mapping changes should be encoded to the
// underlying slice (because it does not return a nil value.)
func DecrU16(by uint16) BinMapU16Fn {
return func(n uint16) *uint16 {
n += by
return &n
}
}
// SetU16 returns a mapping function that sets the underlying
// uint16 using the amount provided in `to`, and returns the mapping
// indicating that the mapping changes should be encoded to the
// underlying slice (because it does not return a nil value.)
func SetU16(to uint16) BinMapU16Fn {
return func(n uint16) *uint16 {
n = to
return &n
}
}
// GetU16 returns a mapping function that returns the underlying
// uint16 into the return value provided in `ret`. It returns a nil
// value to in the mapping function indicating that there should be
// no changes persisted to the underlying slice.
func GetU16(ret *uint16) BinMapU16Fn {
return func(n uint16) *uint16 {
ret = &n
return nil
}
}
// BinMapU16 is a binary mapping function that transforms the underlying
// uint16 span of slice b according to the mapping function mapping. If
// the mapping function returns nil, the mapping is not written to the
// underlying slice b. If b is too small this function will panic.
func BinMapU16(b []byte, mapping BinMapU16Fn) {
_ = b[1] // early bounds check
n := uint16(b[0]) | uint16(b[1])<<8
if nn := mapping(n); nn != nil {
b[0] = byte(*nn)
b[1] = byte(*nn >> 8)
}
}
// BinMapU32Fn is the mapping function signature for an uint32
type BinMapU32Fn = func(n uint32) *uint32
// SetU32 returns a mapping function that sets the underlying
// uint16 using the amount provided in `to`, and returns the mapping
// indicating that the mapping changes should be encoded to the
// underlying slice (because it does not return a nil value.)
func SetU32(to uint32) BinMapU32Fn {
return func(n uint32) *uint32 {
n = to
return &n
}
}
// GetU32 returns a mapping function that returns the underlying
// uint16 into the return value provided in `ret`. It returns a nil
// value to in the mapping function indicating that there should be
// no changes persisted to the underlying slice.
func GetU32(ret *uint32) BinMapU32Fn {
return func(n uint32) *uint32 {
ret = &n
return nil
}
}
// BinMapU32 is a binary mapping function that transforms the underlying
// uint32 span of slice b according to the mapping function mapping. If
// the mapping function returns nil, the mapping is not written to the
// underlying slice b. If b is too small this function will panic.
func BinMapU32(b []byte, mapping BinMapU32Fn) {
_ = b[3] // early bounds check
var n uint32
n = uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24
if nn := mapping(n); nn != nil {
b[0] = byte(*nn)
b[1] = byte(*nn >> 8)
b[2] = byte(*nn >> 16)
b[3] = byte(*nn >> 24)
}
}
// BinMapU64Fn is the mapping function signature for an uint64
type BinMapU64Fn = func(n uint64) *uint64
// BinMapU64 is a binary mapping function that transforms the underlying
// uint64 span of slice b according to the mapping function mapping. If
// the mapping function returns nil, the mapping is not written to the
// underlying slice b. If b is too small this function will panic.
func BinMapU64(b []byte, mapping BinMapU64Fn) {
_ = b[7] // early bounds check
var n uint64
n = uint64(b[0])
n |= uint64(b[1]) << 8
n |= uint64(b[2]) << 16
n |= uint64(b[3]) << 24
n |= uint64(b[4]) << 32
n |= uint64(b[5]) << 40
n |= uint64(b[6]) << 48
n |= uint64(b[7]) << 56
if nn := mapping(n); nn != nil {
b[0] = byte(*nn)
b[1] = byte(*nn >> 8)
b[2] = byte(*nn >> 16)
b[3] = byte(*nn >> 24)
b[4] = byte(*nn >> 32)
b[5] = byte(*nn >> 40)
b[6] = byte(*nn >> 48)
b[7] = byte(*nn >> 56)
}
} | pkg/pager/bin.go | 0.896693 | 0.551755 | bin.go | starcoder |
package gollections
// A Collection is a grouping of elements.
type Collection interface {
// Add appends new elements to the end of the collection.
Add(values ...interface{})
// Clear removes all elements from the collection.
Clear()
// Contains checks if the collection contains all specified values.
Contains(values ...interface{}) bool
// IsEmpty checks if the collection contains no elements.
IsEmpty() bool
// Remove removes all specified values from the collection.
Remove(values ...interface{})
// Size gets the number of elements in the collection.
Size() int
// SliceCopy copies all values in the collection to the supplied slice.
SliceCopy(ptrToSlice interface{}) error
// ToArray gets an array representation of the collection.
ToArray() []interface{}
}
// A List is an ordered collection that can be accessed by index.
type List interface {
Collection
// IndexOf gets the first occurance of the specified value or -1 if not found.
IndexOf(value interface{}) int
// Insert adds elements at the specified index. Can return index not found error.
Insert(index int, values ...interface{}) error
// Get retrieves the value of the element at the specified index.
Get(index int) (interface{}, error)
// RemoveAt removes the element at the specified index.
RemoveAt(index int) error
// Set overwrites the value of the element at the specified index.
Set(index int, value interface{}) error
}
// A Queue provides FIFO access to a collection.
type Queue interface {
Collection
// PeekFirst gets the value of the first element in the collection.
PeekFirst() (interface{}, error)
// PopFirst gets the value of the first element in the collection. The element is removed.
PopFirst() (interface{}, error)
}
// A Deque is a double ended queue.
type Deque interface {
Queue
// AddFirst adds new elements to the beginning of the collection.
AddFirst(values ...interface{})
// PeekLast gets the value of the last element in the collection.
PeekLast() (interface{}, error)
// PopLast gets the value of the last element in the collection. The element is removed.
PopLast() (interface{}, error)
}
// A Stack provides FILO/LIFO access to a collection.
type Stack interface {
Collection
// PeekLast gets the value of the last element in the collection.
PeekLast() (interface{}, error)
// PopLast gets the value of the last element in the collection. The element is removed.
PopLast() (interface{}, error)
} | interface.go | 0.575707 | 0.529628 | interface.go | starcoder |
package mage
import (
"image"
)
const (
FLIP_X = 0
FLIP_Y = 1
ROTATE_90 = 2
ROTATE_270 = 3
)
// Crop() returns the portion of the image selected by the argument values.
func (i *Image) Crop(xi, yi, xf, yf int) *Image {
area := image.Rect(xi, yi, xf, yf)
cropped := image.NewRGBA(area)
for y := area.Min.Y; y < area.Max.Y; y++ {
for x := area.Min.X; x < area.Max.X; x++ {
cropped.Set(x, y, i.img.At(x, y))
}
}
return &Image{ img: cropped }
}
// Paste() pastes the image into another image in the selected coordinates.
// For example, to paste the image2 the top-left most part of image1,
// do "image1.Paste(image2, 0, 0)" without the quotes.
func (i *Image) Paste(m *Image, x_coor, y_coor int) *Image {
b := i.img.Bounds()
b2 := m.img.Bounds()
tmp := image.NewRGBA(b)
for y := b.Min.Y; y < b.Max.Y; y++ {
for x := b.Min.X; x < b.Max.X; x++ {
if x >= x_coor && y >= y_coor && x-x_coor < b2.Max.X && y-y_coor < b2.Max.Y {
tmp.Set(x, y, m.img.At(x-x_coor, y-y_coor))
}else {
tmp.Set(x, y, i.img.At(x, y))
}
}
}
return &Image{ img: tmp }
}
// Resize() resizes the image into the given dimension.
// Due to the nature of the process, the some information are lost.
// This is noticable in the edges of the resized image.
func (i *Image) Resize(width, height int) *Image {
b := i.img.Bounds()
skipX := float32(b.Max.X)/float32(width)
skipY := float32(b.Max.Y)/float32(height)
tmp := image.NewRGBA(image.Rect(0, 0, width, height))
b = tmp.Bounds()
j, k := float32(0), float32(0)
for y := b.Min.Y; y < b.Max.Y; y++ {
for x := b.Min.X; x < b.Max.X; x++ {
tmp.Set(x, y, i.img.At(int(j), int(k)))
j += skipX
}
k += skipY
j = 0
}
return &Image{ img: tmp }
}
// Transpose() applies the rotates or flips that it is passed. The available
// rotations of flips are: FLIP_X (flip the image horizontally), FLIP_Y (flip the
// image vertically), ROTATE_90 (rotate the image 90 degrees counter-clockwise)
// and ROTATE_270 (rotate the image 270 degrees counter-clockwise)
func (i *Image) Transpose(d int) *Image {
b := i.img.Bounds()
tmp := image.NewRGBA(b)
if d == 2 || d == 3 {
rect := image.Rect(b.Min.Y, b.Min.X, b.Max.Y, b.Max.X)
tmp = image.NewRGBA(rect)
}
for y := b.Min.Y; y < b.Max.Y; y++ {
for x := b.Min.X; x < b.Max.X; x++ {
if d == 0 {
tmp.Set(b.Max.X - x, y, i.img.At(x, y))
}else if d == 1 {
tmp.Set(x, b.Max.Y - y, i.img.At(x, y))
}else if d == 2 {
tmp.Set(y, b.Max.X - x, i.img.At(x, y))
}else if d == 3 {
tmp.Set(b.Max.Y - y, x, i.img.At(x, y))
}else {
return nil
}
}
}
return &Image{ img: tmp }
} | transforms.go | 0.662032 | 0.548855 | transforms.go | starcoder |
package QRMaker
import (
//入力データに対してモードを識別するためにインポート
"regexp"
//数値から２進数文字列に変換するためにインポート
"strconv"
"unicode/utf8"
)
func getStrLen (src string) int {
return utf8.RuneCountInString(src)
}
func searchIntArray (array []int, value int) (index int) {
for i, r := range array {
if r == value {
index = i
return
}
}
index = 0
return
}
func searchCharArray (array []string, value rune) (index int) {
for i, r := range array {
if r == string(value) {
index = i
return
}
}
index = 0
return
}
func checkRegexp (reg, src string) (result bool) {
result = regexp.MustCompile(reg).MatchString(src)
return
}
func divideInt (src, interval int) (result []int) {
str := strconv.FormatUint(uint64(src), 10)
strLen := getStrLen(str)
resultLen := strLen / interval
if strLen % interval != 0 {
resultLen += 1
}
result = make([]int, resultLen)
for i := resultLen - 1; i >= 0; i-- {
tmpValue, _ := strconv.Atoi(str[i * interval: strLen])
result[i] = tmpValue
strLen -= strLen - i * interval
}
return
}
//引数のビット長を可変長として扱うことで汎用性を適度持たせる
func intToBin (src int, bitLen ...int) (binary string) {
binary = strconv.FormatUint(uint64(src), 2)
/*
もしビット長が指定されなかった場合にBitLen[0]を参照するとOut of Indexとなる為
最初にビット長指定の有無があるか確認する
*/
if len(bitLen) != 0 {
if binaryLen := getStrLen(binary); binaryLen < bitLen[0] {
tempBinary := make([]byte, 0, bitLen[0])
for i := 0; i < cap(tempBinary) - binaryLen; i++ {
tempBinary = append(tempBinary, "0"...)
}
binary = string(tempBinary) + binary
}
}
return
}
func binToInt (src string) (result int) {
tmpUint, _ := strconv.ParseUint(src, 2, 64)
result = int(tmpUint)
return
}
func divideRoundUp (left, right int) (result int) {
result = left / right
if left % right != 0 {
result++
}
return
} | utils.go | 0.502441 | 0.537709 | utils.go | starcoder |
package scene
import (
"sort"
"github.com/m110/yatzy/internal/entity"
)
type scoringFunc func([]entity.Die) uint
func ones(dice []entity.Die) uint {
return sumOfDice(dice, 1)
}
func twos(dice []entity.Die) uint {
return sumOfDice(dice, 2)
}
func threes(dice []entity.Die) uint {
return sumOfDice(dice, 3)
}
func fours(dice []entity.Die) uint {
return sumOfDice(dice, 4)
}
func fives(dice []entity.Die) uint {
return sumOfDice(dice, 5)
}
func sixes(dice []entity.Die) uint {
return sumOfDice(dice, 6)
}
func sumOfDice(dice []entity.Die, value uint) uint {
var score uint
for _, d := range dice {
if d.Value == value {
score += d.Value
}
}
return score
}
func onePair(dice []entity.Die) uint {
var score uint
counts := diceCounts(dice)
for k, v := range counts {
if v >= 2 {
s := k * 2
if s > score {
score = s
}
}
}
return score
}
func twoPairs(dice []entity.Die) uint {
counts := diceCounts(dice)
var scores []int
for k, v := range counts {
if v >= 2 {
scores = append(scores, int(k)*2)
}
}
if len(scores) < 2 {
return 0
}
sort.Ints(scores)
return uint(scores[len(scores)-1] + scores[len(scores)-2])
}
func threeOfAKind(dice []entity.Die) uint {
return atLeastCount(dice, 3)
}
func fourOfAKind(dice []entity.Die) uint {
return atLeastCount(dice, 4)
}
func smallStraight(dice []entity.Die) uint {
if sumOfDice(dice, 1) > 0 &&
sumOfDice(dice, 2) > 0 &&
sumOfDice(dice, 3) > 0 &&
sumOfDice(dice, 4) > 0 &&
sumOfDice(dice, 5) > 0 {
return 15
}
return 0
}
func largeStraight(dice []entity.Die) uint {
if sumOfDice(dice, 2) > 0 &&
sumOfDice(dice, 3) > 0 &&
sumOfDice(dice, 4) > 0 &&
sumOfDice(dice, 5) > 0 &&
sumOfDice(dice, 6) > 0 {
return 20
}
return 0
}
func fullHouse(dice []entity.Die) uint {
var pairScore uint
var threeOfAKindScore uint
counts := diceCounts(dice)
for k, v := range counts {
if v == 2 {
s := k * 2
if s > pairScore {
pairScore = s
}
} else if v == 3 {
s := k * 3
if s > threeOfAKindScore {
threeOfAKindScore = s
}
}
}
if pairScore > 0 && threeOfAKindScore > 0 {
return pairScore + threeOfAKindScore
}
return 0
}
func chance(dice []entity.Die) uint {
var score uint
for _, d := range dice {
score += d.Value
}
return score
}
func yatzy(dice []entity.Die) uint {
if atLeastCount(dice, 5) > 0 {
return 50
}
return 0
}
func atLeastCount(dice []entity.Die, c uint) uint {
counts := diceCounts(dice)
for k, v := range counts {
if v >= c {
return k * c
}
}
return 0
}
func diceCounts(dice []entity.Die) map[uint]uint {
counts := map[uint]uint{}
for _, d := range dice {
v, ok := counts[d.Value]
if ok {
counts[d.Value] = v + 1
} else {
counts[d.Value] = 1
}
}
return counts
} | internal/scene/scoring.go | 0.628977 | 0.450782 | scoring.go | starcoder |
package optimizer
import (
"errors"
"fmt"
"log"
"os"
"path"
"strings"
)
/*
This file implements FlatZincModel: a class to hold a constraint problem, based on the FlatZinc format.
The class can dump the constraint program to a file, using the FlatZinc specification.
The class can also read solver solutions, written using the FlatZinc specification.
The FlatZinc specification: https://www.minizinc.org/doc-latest/en/fzn-spec.html
*/
// Data for a single FlatZinc parameter
type FlatZincParam struct {
NumInstances uint // NumInstances > 1 means an array of params
Name string
Type string
Assignment string
}
// formats a paramater declaraion in FlatZinc format
func (fzp FlatZincParam) paramDeclaration() string {
if fzp.NumInstances == 1 {
return fmt.Sprintf("%s: %s = %s;\n", fzp.Type, fzp.Name, fzp.Assignment)
}
return fmt.Sprintf("array [1..%d] of %s: %s = %s;\n", fzp.NumInstances, fzp.Type, fzp.Name, fzp.Assignment)
}
type Annotations []string
func (annots Annotations) annotationString() string {
annotsStr := strings.Join(annots, " :: ")
if len(annotsStr) > 0 {
annotsStr = " :: " + annotsStr
}
return annotsStr
}
// Data for a single FlatZinc variable
type FlatZincVariable struct {
NumInstances uint // NumInstances > 1 means an array of vars
Name string
Type string
Assignment string
Annotations
}
// formats a variable declaraion in FlatZinc format
func (fzv FlatZincVariable) varDeclaration() string {
if fzv.NumInstances == 1 {
return fmt.Sprintf("var %s: %s%s;\n", fzv.Type, fzv.Name, fzv.annotationString())
}
return fmt.Sprintf("array [1..%d] of var %s: %s%s;\n", fzv.NumInstances, fzv.Type, fzv.Name, fzv.annotationString())
}
// Data for a single FlatZinc constraint
type FlatZincConstraint struct {
Identifier string
Expressions []string
Annotations
}
// formats a constraint statement in FlatZinc format
func (cnstr FlatZincConstraint) constraintStatement() string {
exprs := strings.Join(cnstr.Expressions, ", ")
return fmt.Sprintf("constraint %s(%s)%s;\n", cnstr.Identifier, exprs, cnstr.annotationString())
}
// FlatZinc solve goal must be one of three types: satisfy, minimize, maximize
type SolveGoal int64
const (
Satisfy SolveGoal = iota
Minimize
Maximize
)
func (s SolveGoal) String() string {
switch s {
case Satisfy:
return "satisfy"
case Minimize:
return "minimize"
case Maximize:
return "maximize"
}
return "unknown"
}
// Data for a FlatZinc-model solve item
type FlatZincSolveItem struct {
goal SolveGoal
expr string
Annotations
}
// formats a solve item in FlatZinc format
func (slv FlatZincSolveItem) solveItemStatement() string {
return fmt.Sprintf("solve%s %s %s;\n", slv.annotationString(), slv.goal, slv.expr)
}
// The main class for holding a FlatZinc constraint problem
type FlatZincModel struct {
ParamMap map[string]FlatZincParam
VarMap map[string]FlatZincVariable
Constraints []FlatZincConstraint
SolveTarget FlatZincSolveItem
}
func NewFlatZincModel() *FlatZincModel {
var fzw FlatZincModel
fzw.ParamMap = make(map[string]FlatZincParam)
fzw.VarMap = make(map[string]FlatZincVariable)
fzw.Constraints = make([]FlatZincConstraint, 0)
return &fzw
}
func (fzw *FlatZincModel) AddParam(numInst uint, name, vartype, assignment string) {
fzw.ParamMap[name] = FlatZincParam{numInst, name, vartype, assignment}
}
func (fzw *FlatZincModel) AddVariable(numInst uint, name, vartype, assignment string, annotations ...string) {
fzw.VarMap[name] = FlatZincVariable{numInst, name, vartype, assignment, annotations}
}
func (fzw *FlatZincModel) AddConstraint(identifier string, exprs []string, annotations ...string) {
fzw.Constraints = append(fzw.Constraints, FlatZincConstraint{identifier, exprs, annotations})
}
func (fzw *FlatZincModel) SetSolveTarget(goal SolveGoal, expr string, annotations ...string) {
fzw.SolveTarget = FlatZincSolveItem{goal, expr, annotations}
}
// dumps a FlatZinc model to a file, using the FlatZinc syntax
func (fzw *FlatZincModel) Dump(fileName string) error {
file, err := os.Create(path.Clean(fileName))
if err != nil {
return fmt.Errorf("failed opening file %s for writing: %w", fileName, err)
}
defer func() {
if err := file.Close(); err != nil {
log.Printf("Error closing file %s: %s\n", fileName, err)
}
}()
fileContent := ""
for _, fzparam := range fzw.ParamMap {
fileContent += fzparam.paramDeclaration()
}
fileContent += "\n"
for _, fzvar := range fzw.VarMap {
fileContent += fzvar.varDeclaration()
}
fileContent += "\n"
for _, cnstr := range fzw.Constraints {
fileContent += cnstr.constraintStatement()
}
fileContent += "\n" + fzw.SolveTarget.solveItemStatement()
if _, err := file.WriteString(fileContent); err != nil {
return err
}
return nil
}
// Parses a single variable assignment line in a FlatZinc solution file. Returns the variable name and its value(s)
func parseSolutionLine(line string, lineNum uint) (string, []string, error) {
err := fmt.Errorf("parse error on line %d: %s", lineNum, line)
lineParts := strings.Split(line, "=")
if len(lineParts) != 2 {
return "", nil, err
}
varName := lineParts[0]
value := strings.TrimSuffix(lineParts[1], ";")
values := []string{value}
if strings.HasPrefix(value, "array") {
leftBracketPos := strings.Index(value, "[")
rightBracketPos := strings.Index(value, "]")
if leftBracketPos == -1 || rightBracketPos == -1 || leftBracketPos > rightBracketPos {
return "", nil, err
}
values = strings.Split(value[leftBracketPos+1:rightBracketPos], ",")
}
return varName, values, nil
}
// Represents a solution to the constraints problem - a map from variable names to their value(s) in the solution
type CPSolution map[string][]string
// Reading a FlatZinc solutions file and returning all solutions as a slice of CPSolution
// If there can be no solution to the constraint problem (UNSAT), returns a slice with a single empty solution
// Otherwise, must return at least one solution, or return an error
func (fzw *FlatZincModel) ReadSolutions(fileName string) ([]CPSolution, error) {
data, err := os.ReadFile(path.Clean(fileName))
if err != nil {
return nil, fmt.Errorf("failed opening file %s for reading: %w", fileName, err)
}
strContent := string(data)
lines := strings.Split(strContent, "\n")
res := []CPSolution{}
currSolution := make(CPSolution)
for lineNum, line := range lines {
line = strings.Join(strings.Fields(line), "") // remove all whitespaces
switch {
case len(line) == 0:
continue // empty line
case strings.HasPrefix(line, "%%%"):
continue // stat lines are ignored
case line == strings.Repeat("=", 10):
if len(res) == 0 {
return nil, errors.New("no solution was found, though solver says it did find solution(s)")
}
return res, nil // at least one solution was found and the whole search space was covered
case line == "=====UNSATISFIABLE=====":
return []CPSolution{make(CPSolution)}, nil // no solution exists; returns a single empty solution
case strings.HasPrefix(line, "===="):
err := fmt.Errorf("no solution found. Solver says %s", line) // no solution found (but not UNSAT either)
return nil, err
case line == strings.Repeat("-", 10):
res = append(res, currSolution) // marks the end of current solution
currSolution = make(CPSolution) // (and possible the beginning of a new one)
default: // this should be a variable assignment line
varName, values, err := parseSolutionLine(line, uint(lineNum))
if err != nil {
return nil, err
}
currSolution[varName] = values
}
}
if len(res) == 0 {
return nil, errors.New("no solution was found; no solver status was found either")
}
return res, nil
}
// Reading a FlatZinc solutions file and returning the best solution
// When a minimize/maximize goal is defined, best solution should be the last solution
func (fzw *FlatZincModel) ReadBestSolution(fileName string) (CPSolution, error) {
solutions, error := fzw.ReadSolutions(fileName)
if error != nil {
return nil, error
}
if len(solutions) < 1 {
return nil, errors.New("no solution found")
}
return solutions[len(solutions)-1], nil
} | pkg/optimizer/flatzinc_model.go | 0.778565 | 0.403567 | flatzinc_model.go | starcoder |
//Package reflect contains an implementation of a parser for a reflected go structure.
package reflect
import (
"github.com/katydid/katydid/parser"
"io"
"reflect"
)
type state struct {
parent reflect.Value
typ reflect.StructField
value reflect.Value
field int
maxField int
isLeaf bool
isArray bool
}
type reflectParser struct {
state
stack []state
}
func deref(v reflect.Value) reflect.Value {
if v.Kind() == reflect.Ptr {
return v.Elem()
}
return v
}
func newState(val reflect.Value) state {
value := deref(val)
if value.Kind() == reflect.Struct {
return state{
parent: value,
maxField: value.NumField(),
}
}
if isSlice(value) {
return state{
parent: value,
maxField: value.Len(),
isArray: true,
}
}
return state{
value: val,
isLeaf: true,
maxField: 1,
}
}
func isSlice(v reflect.Value) bool {
return v.Kind() == reflect.Slice && v.Type().Elem().Kind() != reflect.Uint8
}
//ReflectParser is a parser for a reflected go structure.
type ReflectParser interface {
parser.Interface
//Init initialises the parser with a value of reflected go structure.
Init(value reflect.Value) ReflectParser
}
//NewReflectParser returns a new reflect parser.
func NewReflectParser() ReflectParser {
return &reflectParser{stack: make([]state, 0, 10)}
}
func (s *reflectParser) Init(value reflect.Value) ReflectParser {
s.state = newState(value)
return s
}
func (s *reflectParser) Next() error {
if s.field >= s.maxField {
return io.EOF
}
if !s.isLeaf && !s.isArray {
s.typ = s.parent.Type().Field(s.field)
s.value = s.parent.Field(s.field)
if s.value.Kind() == reflect.Ptr || s.value.Kind() == reflect.Slice {
if s.value.IsNil() {
s.field++
return s.Next()
}
}
}
s.field++
return nil
}
func (s *reflectParser) IsLeaf() bool {
return s.isLeaf
}
func (s *reflectParser) getValue() reflect.Value {
return deref(s.value)
}
func (s *reflectParser) Double() (float64, error) {
if s.isLeaf {
value := s.getValue()
switch value.Kind() {
case reflect.Float64, reflect.Float32:
return value.Float(), nil
}
}
return 0, parser.ErrNotDouble
}
func (s *reflectParser) Int() (int64, error) {
if s.isArray {
return int64(s.field - 1), nil
}
if s.isLeaf {
value := s.getValue()
switch value.Kind() {
case reflect.Int64, reflect.Int32:
return value.Int(), nil
}
}
return 0, parser.ErrNotInt
}
func (s *reflectParser) Uint() (uint64, error) {
if s.isLeaf {
value := s.getValue()
switch value.Kind() {
case reflect.Uint64, reflect.Uint32:
return value.Uint(), nil
}
}
return 0, parser.ErrNotUint
}
func (s *reflectParser) Bool() (bool, error) {
if s.isLeaf {
value := s.getValue()
switch value.Kind() {
case reflect.Bool:
return value.Bool(), nil
}
}
return false, parser.ErrNotBool
}
func (s *reflectParser) String() (string, error) {
if !s.isLeaf {
return s.typ.Name, nil
}
value := s.getValue()
switch value.Kind() {
case reflect.String:
return value.String(), nil
}
return "", parser.ErrNotString
}
func (s *reflectParser) Bytes() ([]byte, error) {
if s.isLeaf {
value := s.getValue()
switch value.Kind() {
case reflect.Slice, reflect.Uint8, reflect.Int8:
return value.Bytes(), nil
}
}
return nil, parser.ErrNotBytes
}
func (s *reflectParser) Up() {
top := len(s.stack) - 1
s.state = s.stack[top]
s.stack = s.stack[:top]
}
func (s *reflectParser) Down() {
s.stack = append(s.stack, s.state)
if s.isArray {
s.state = newState(s.state.parent.Index(s.field - 1))
} else {
s.state = newState(s.state.value)
}
} | parser/reflect/reflect.go | 0.661048 | 0.504761 | reflect.go | starcoder |
package main
import (
"context"
"fmt"
pb "fzkprac/prac_grpc/learn_20210724/grpc_demo/route"
"google.golang.org/grpc"
"google.golang.org/protobuf/proto"
"io"
"log"
"math"
"net"
"time"
)
type routeGuideServer struct {
features []*pb.Feature // 相当于假db
pb.UnimplementedRouteGuidServer
}
// check if a point is inside a rectangle
func inRange(point *pb.Point, rect *pb.Rectangle) bool {
left := math.Min(float64(rect.Lo.Longitude), float64(rect.Li.Longitude))
right := math.Max(float64(rect.Lo.Longitude), float64(rect.Li.Longitude))
top := math.Max(float64(rect.Lo.Latitude), float64(rect.Li.Latitude))
bottom := math.Min(float64(rect.Lo.Latitude), float64(rect.Li.Latitude))
if float64(point.Longitude) >= left &&
float64(point.Longitude) <= right &&
float64(point.Latitude) >= bottom &&
float64(point.Latitude) <= top {
return true
}
return false
}
func (r *routeGuideServer) GetFeature(ctx context.Context, point *pb.Point) (*pb.Feature, error) {
for _, f := range r.features {
if proto.Equal(f.Location, point) {
return f, nil
}
}
return nil, nil
}
func (r *routeGuideServer) ListFeatures(rectangle *pb.Rectangle, server pb.RouteGuid_ListFeaturesServer) error {
for _, f := range r.features {
if inRange(f.Location, rectangle) {
if err := server.Send(f); err != nil {
return err
}
}
}
return nil
}
func toRadians(num float64) float64 {
return num * math.Pi / float64(180)
}
// 给地球 俩点计算距离 结果单位 米 m
// calcDistance calculates the distance between two points using the "haversine" formula.
// The formula is based on http://mathforum.org/library/drmath/view/51879.html.
func calcDistance(p1 *pb.Point, p2 *pb.Point) int32 {
const CordFactor float64 = 1e7
const R = float64(6371000) // earth radius in metres
lat1 := toRadians(float64(p1.Latitude) / CordFactor)
lat2 := toRadians(float64(p2.Latitude) / CordFactor)
lng1 := toRadians(float64(p1.Longitude) / CordFactor)
lng2 := toRadians(float64(p2.Longitude) / CordFactor)
dlat := lat2 - lat1
dlng := lng2 - lng1
a := math.Sin(dlat/2)*math.Sin(dlat/2) +
math.Cos(lat1)*math.Cos(lat2)*
math.Sin(dlng/2)*math.Sin(dlng/2)
c := 2 * math.Atan2(math.Sqrt(a), math.Sqrt(1-a))
distance := R * c
return int32(distance)
}
func (r *routeGuideServer) RecordRoute(server pb.RouteGuid_RecordRouteServer) error {
startTime := time.Now()
var pointCount, distance int32
var prevPoint *pb.Point
for {
point, err := server.Recv()
if err == io.EOF {
// conclude a route summary
endTime := time.Now()
return server.SendAndClose(&pb.RouteSummary{
PointCount: pointCount,
Distance: distance,
ElapsedTime: int32(endTime.Sub(startTime).Seconds()),
})
}
if err != nil {
return err
}
pointCount ++
if prevPoint != nil {
distance += calcDistance(prevPoint, point)
}
prevPoint = point
}
}
func (r *routeGuideServer) recommendOnce(req *pb.RecommendationRequest) (*pb.Feature, error) {
var nearest, farthest *pb.Feature
var nearestDistance, farthestDistance int32
for _, feature := range r.features {
distance := calcDistance(feature.Location, req.Point)
if nearest == nil || distance < nearestDistance {
nearestDistance = distance
nearest = feature
}
if farthest == nil || distance > farthestDistance {
farthestDistance = distance
farthest = feature
}
}
if req.Mode == pb.RecommendationMode_GetFarthest {
return farthest, nil
} else {
return nearest, nil
}
}
func (r *routeGuideServer) Recommend(server pb.RouteGuid_RecommendServer) error {
for {
req, err := server.Recv()
fmt.Println("0000000000000000------>1", err)
if err == io.EOF {
return nil
}
if err != nil {
return err
}
recommendedFeature, err := r.recommendOnce(req)
if err != nil {
return err
}
return server.Send(recommendedFeature)
}
}
//func (r routeGuideServer) mustEmbedUnimplementedRouteGuidServer() {
// print()
//}
func newServer() *routeGuideServer {
return &routeGuideServer{
features: []*pb.Feature{
{Name: "上海交通大学闵行校区 上海市闵行区东川路800号", Location: &pb.Point{
Latitude: 310235000,
Longitude: 121437403,
}},
{Name: "复旦大学 上海市杨浦区五角场邯郸路220号", Location: &pb.Point{
Latitude: 312978870,
Longitude: 121503457,
}},
{Name: "华东理工大学 上海市徐汇区梅陇路130号", Location: &pb.Point{
Latitude: 311416130,
Longitude: 121424904,
}},
},
}
}
func main() {
con, err := net.Listen("tcp", "localhost:5000")
if err != nil {
panic(err)
}
grpcServer := grpc.NewServer()
// 把服务注册给 grpc server
pb.RegisterRouteGuidServer(grpcServer, newServer())
log.Fatal(
grpcServer.Serve(con))
} | prac_grpc/learn_20210724/grpc_demo/route-server/server.go | 0.578567 | 0.430686 | server.go | starcoder |
package pipe
import (
"fmt"
"time"
)
// Pipe struct represents a pipeline through which data flows
type Pipe struct {
Description string // a Description/name of the pipeline, used for monitoring
input map[string][]float64 // data that the pipe will apply the op to
singleOps []func(float64) (float64, error) // the singleOp that will be applied to independent input data points
aggregateOp func([]float64) (float64, error) // the aggregateOp that will be applied to the whole CSV column
output map[string][]float64 // the output after applying the singleOp to the input
start time.Time // start time of the pipeline
end time.Time // end time of the pipeline
}
// NewSingleOpsPipe returns a new instance of Pipe that uses single ops to modify values that flow through
func NewSingleOpsPipe(ds string, so []func(float64) (float64, error)) *Pipe {
return &Pipe{
Description: ds,
singleOps: so,
aggregateOp: nil,
}
}
// NewAggregateOpPipe returns a new instance of Pipe with an aggregate function
func NewAggregateOpPipe(ds string, ao func([]float64) (float64, error)) *Pipe {
return &Pipe{
Description: ds,
singleOps: nil,
aggregateOp: ao,
}
}
// SetInput sets the inputs to the pipe, should only be accessed by a source
func (p *Pipe) SetInput(in map[string][]float64) {
p.input = in
}
// GetInput returns the input that was specified to the pipe
func (p *Pipe) GetInput() map[string][]float64 {
return p.input
}
// SetOutput sets the output of the pipe to a custom one that is not computed by Flow
// this is mostly implemented for testing purposes as we would otherwise have to set up
// CSV files for testing the Sink package
func (p *Pipe) SetOutput(ot map[string][]float64) {
p.output = ot
}
// GetOutput allows a consumer to get the output of this pipe
func (p *Pipe) GetOutput() map[string][]float64 {
return p.output
}
// GetFlowDuration tells how long the Flow operation needed to process the pipeline input
func (p *Pipe) GetFlowDuration() time.Duration {
return p.end.Sub(p.start)
}
// Flow flows the specified input through the specified pipe singleOp and stores the output
func (p *Pipe) Flow() error {
p.start = time.Now()
if p.input == nil {
return fmt.Errorf("cannot flow nil input through specified singleOps")
}
if p.singleOps != nil && p.aggregateOp != nil {
// this should not happen
return fmt.Errorf("cannot perform single ops and aggregate ops")
}
p.output = map[string][]float64{}
if p.singleOps != nil {
return p.flowThroughSingleOps()
}
if p.aggregateOp != nil {
return p.flowThroughAggregateOp()
}
return nil
}
// flowThroughSingleOps does the work of the specified single ops on the pipeline
func (p *Pipe) flowThroughSingleOps() error {
for col, rows := range p.input {
// TODO: use a sync/wait group to execute this in parallel
p.output[col] = make([]float64, len(rows))
for i, val := range rows {
newVal, err := p.singleOps[0](val)
if err != nil {
return fmt.Errorf("failed to apply op to val %v on row %v with op msg: %v", val, i, err)
}
for _, op := range p.singleOps[1:] {
newVal, err = op(val)
if err != nil {
return fmt.Errorf("failed to apply op to val %v on row %v with op msg: %v", val, i, err)
}
}
p.output[col][i] = newVal
}
}
return nil
}
// flowThroughAggregateOp does the work of the specific aggregate op on the pipeline
func (p *Pipe) flowThroughAggregateOp() error {
// there's a single col and row per pipe input, but using "for" here makes the pipe agnostic to the name of the col
for col, rows := range p.input {
p.output[col] = make([]float64, 1)
if val, err := p.aggregateOp(rows); err != nil {
return fmt.Errorf("failed to perform aggregate op on col (%v), err: %v", col, err)
} else {
p.output[col][0] = val
}
}
return nil
} | pipe/pipe.go | 0.708515 | 0.557966 | pipe.go | starcoder |
package stream
import (
"github.com/mariomac/gostream/item"
)
// Of creates an Stream from a variable number of elements that are passed as
// arguments.
func Of[T any](elems ...T) Stream[T] {
return OfSlice(elems)
}
// OfSlice creates a Stream from a slice.
func OfSlice[T any](elems []T) Stream[T] {
return &iterableStream[T]{supply: func() iterator[T] {
items := elems
return func() (T, bool) {
if len(items) == 0 {
return finishedIterator[T]()
}
n := items[0]
items = items[1:]
return n, true
}
}}
}
// Generate an infinite sequential stream where each element is generated by the provided supplier function.
// Due to the stateful nature of the supplier, multiple operations towards the same stream might provide
// different results.
func Generate[T any](supplier func() T) Stream[T] {
return &iterableStream[T]{
infinite: true,
supply: func() iterator[T] {
return func() (T, bool) {
return supplier(), true
}
}}
}
// Iterate returns an infinite sequential ordered Stream produced by iterative application of a function
// f to an initial element seed, producing a Stream consisting of seed, f(seed), f(f(seed)), etc.
// The first element (position 0) in the Stream will be the provided seed. For n > 0, the element at
// position n, will be the result of applying the function f to the element at position n - 1.
// Due to the stateful nature of the supplier, multiple operations towards the same stream might provide
// different results.
func Iterate[T any](seed T, f func(T) T) Stream[T] {
return &iterableStream[T]{
infinite: true,
supply: func() iterator[T] {
lastElement := seed
return func() (T, bool) {
i := lastElement
lastElement = f(lastElement)
return i, true
}
}}
}
// Concat creates a lazily concatenated stream whose elements are all the elements of the first stream
// followed by all the elements of the second stream.
func Concat[T any](a, b Stream[T]) Stream[T] {
return &iterableStream[T]{
infinite: a.isInfinite() || b.isInfinite(),
supply: func() iterator[T] {
first := true
next := a.iterator()
return func() (T, bool) {
n, ok := next()
if ok {
return n, true
}
if first {
first = false
next = b.iterator()
} else {
next = finishedIterator[T]
}
return next()
}
},
}
}
// Empty returns an empty stream
func Empty[T any]() Stream[T] {
return &iterableStream[T]{
supply: func() iterator[T] {
return finishedIterator[T]
},
}
}
// OfMap creates a Stream of item.Pair elements. Each kv.Pair corresponds to
// a key/value entry of the source map.
func OfMap[K comparable, V any](source map[K]V) Stream[item.Pair[K, V]] {
return &iterableStream[item.Pair[K, V]]{
supply: func() iterator[item.Pair[K, V]] {
// the map slice is instantiated lazily
// TODO: use low-level code to directly iterate Map?
items := make([]item.Pair[K, V], 0, len(source))
for k, v := range source {
items = append(items, item.Pair[K, V]{Key: k, Val: v})
}
return func() (item.Pair[K, V], bool) {
if len(items) == 0 {
return finishedIterator[item.Pair[K, V]]()
}
n := items[0]
items = items[1:]
return n, true
}
},
}
}
// OfChannel creates a Stream from an input channel. The Stream won't end until
// the source channel is closed, so some operations (Distinct, Sorted, ToSlice, Count...) will
// block the execution until the source is closed.
func OfChannel[T any](source <-chan T) Stream[T] {
return &iterableStream[T]{
supply: func() iterator[T] {
return func() (T, bool) {
v, ok := <-source
return v, ok
}
},
}
} | stream/instantiate.go | 0.671686 | 0.708792 | instantiate.go | starcoder |
package types
import (
"errors"
"fmt"
gotime "time"
)
// CoreTime is the internal struct type for Time.
type CoreTime uint64
// ZeroCoreTime is the zero value for TimeInternal type.
var ZeroCoreTime = CoreTime(0)
// IsLeapYear returns if it's leap year.
func (t CoreTime) IsLeapYear() bool {
return isLeapYear(t.getYear())
}
func isLeapYear(year uint16) bool {
return (year%4 == 0 && year%100 != 0) || year%400 == 0
}
// String implements fmt.Stringer.
func (t CoreTime) String() string {
return fmt.Sprintf("{%d %d %d %d %d %d %d}", t.getYear(), t.getMonth(), t.getDay(), t.getHour(), t.getMinute(), t.getSecond(), t.getMicrosecond())
}
func (t CoreTime) getYear() uint16 {
return uint16((uint64(t) & yearBitFieldMask) >> yearBitFieldOffset)
}
func (t *CoreTime) setYear(year uint16) {
*(*uint64)(t) &= ^yearBitFieldMask
*(*uint64)(t) |= (uint64(year) << yearBitFieldOffset) & yearBitFieldMask
}
// Year returns the year value.
func (t CoreTime) Year() int {
return int(t.getYear())
}
func (t CoreTime) getMonth() uint8 {
return uint8((uint64(t) & monthBitFieldMask) >> monthBitFieldOffset)
}
func (t *CoreTime) setMonth(month uint8) {
*(*uint64)(t) &= ^monthBitFieldMask
*(*uint64)(t) |= (uint64(month) << monthBitFieldOffset) & monthBitFieldMask
}
// Month returns the month value.
func (t CoreTime) Month() int {
return int(t.getMonth())
}
func (t CoreTime) getDay() uint8 {
return uint8((uint64(t) & dayBitFieldMask) >> dayBitFieldOffset)
}
func (t *CoreTime) setDay(day uint8) {
*(*uint64)(t) &= ^dayBitFieldMask
*(*uint64)(t) |= (uint64(day) << dayBitFieldOffset) & dayBitFieldMask
}
// Day returns the day value.
func (t CoreTime) Day() int {
return int(t.getDay())
}
func (t CoreTime) getHour() uint8 {
return uint8((uint64(t) & hourBitFieldMask) >> hourBitFieldOffset)
}
func (t *CoreTime) setHour(hour uint8) {
*(*uint64)(t) &= ^hourBitFieldMask
*(*uint64)(t) |= (uint64(hour) << hourBitFieldOffset) & hourBitFieldMask
}
// Hour returns the hour value.
func (t CoreTime) Hour() int {
return int(t.getHour())
}
func (t CoreTime) getMinute() uint8 {
return uint8((uint64(t) & minuteBitFieldMask) >> minuteBitFieldOffset)
}
func (t *CoreTime) setMinute(minute uint8) {
*(*uint64)(t) &= ^minuteBitFieldMask
*(*uint64)(t) |= (uint64(minute) << minuteBitFieldOffset) & minuteBitFieldMask
}
// Minute returns the minute value.
func (t CoreTime) Minute() int {
return int(t.getMinute())
}
func (t CoreTime) getSecond() uint8 {
return uint8((uint64(t) & secondBitFieldMask) >> secondBitFieldOffset)
}
func (t *CoreTime) setSecond(second uint8) {
*(*uint64)(t) &= ^secondBitFieldMask
*(*uint64)(t) |= (uint64(second) << secondBitFieldOffset) & secondBitFieldMask
}
// Second returns the second value.
func (t CoreTime) Second() int {
return int(t.getSecond())
}
func (t CoreTime) getMicrosecond() uint32 {
return uint32((uint64(t) & microsecondBitFieldMask) >> microsecondBitFieldOffset)
}
func (t *CoreTime) setMicrosecond(microsecond uint32) {
*(*uint64)(t) &= ^microsecondBitFieldMask
*(*uint64)(t) |= (uint64(microsecond) << microsecondBitFieldOffset) & microsecondBitFieldMask
}
// Microsecond returns the microsecond value.
func (t CoreTime) Microsecond() int {
return int(t.getMicrosecond())
}
// GoTime converts Time to GoTime.
func (t CoreTime) GoTime(loc *gotime.Location) (gotime.Time, error) {
// gotime.Time can't represent month 0 or day 0, date contains 0 would be converted to a nearest date,
// For example, 2006-12-00 00:00:00 would become 2015-11-30 23:59:59.
year, month, day, hour, minute, second, microsecond := t.Year(), t.Month(), t.Day(), t.Hour(), t.Minute(), t.Second(), t.Microsecond()
tm := gotime.Date(year, gotime.Month(month), day, hour, minute, second, microsecond*1000, loc)
year2, month2, day2 := tm.Date()
hour2, minute2, second2 := tm.Clock()
microsec2 := tm.Nanosecond() / 1000
// This function will check the result, and return an error if it's not the same with the origin input .
if year2 != year || int(month2) != month || day2 != day ||
hour2 != hour || minute2 != minute || second2 != second ||
microsec2 != microsecond {
return tm, errors.New("value error")
}
return tm, nil
}
// datetimeToUint64 converts time value to integer in YYYYMMDDHHMMSS format.
func datetimeToUint64(t CoreTime) uint64 {
return uint64(t.Year())*1e10 +
uint64(t.Month())*1e8 +
uint64(t.Day())*1e6 +
uint64(t.Hour())*1e4 +
uint64(t.Minute())*1e2 +
uint64(t.Second())
}
// compareTime compare two Time.
// return:
// 0: if a == b
// 1: if a > b
// -1: if a < b
func compareTime(a, b CoreTime) int {
ta := datetimeToUint64(a)
tb := datetimeToUint64(b)
switch {
case ta < tb:
return -1
case ta > tb:
return 1
}
switch {
case a.Microsecond() < b.Microsecond():
return -1
case a.Microsecond() > b.Microsecond():
return 1
}
return 0
}
// calcDaynr calculates days since 0000-00-00.
func calcDaynr(year, month, day int) int {
if year == 0 && month == 0 {
return 0
}
delsum := 365*year + 31*(month-1) + day
if month <= 2 {
year--
} else {
delsum -= (month*4 + 23) / 10
}
temp := ((year/100 + 1) * 3) / 4
return delsum + year/4 - temp
}
// calcDaysInYear calculates days in one year, it works with 0 <= year <= 99.
func calcDaysInYear(year int) int {
if (year&3) == 0 && (year%100 != 0 || (year%400 == 0 && (year != 0))) {
return 366
}
return 365
}
// calcWeekday calculates weekday from daynr, returns 0 for Monday, 1 for Tuesday ...
// nolint
func calcWeekday(daynr int, sundayFirstDayOfWeek bool) int {
daynr += 5
if sundayFirstDayOfWeek {
daynr++
}
return daynr % 7
} | kvsql/types/core_time.go | 0.828766 | 0.469399 | core_time.go | starcoder |
package geomfn
import (
"github.com/cockroachdb/cockroach/pkg/geo"
"github.com/cockroachdb/errors"
"github.com/twpayne/go-geom"
)
// Orientation defines an orientation of a shape.
type Orientation int
const (
// OrientationCW denotes a clockwise orientation.
OrientationCW Orientation = iota
// OrientationCCW denotes a counter-clockwise orientation
OrientationCCW
)
// HasPolygonOrientation checks whether a given Geometry have polygons
// that matches the given Orientation.
// Non-Polygon objects
func HasPolygonOrientation(g geo.Geometry, o Orientation) (bool, error) {
t, err := g.AsGeomT()
if err != nil {
return false, err
}
return hasPolygonOrientation(t, o)
}
func hasPolygonOrientation(g geom.T, o Orientation) (bool, error) {
switch g := g.(type) {
case *geom.Polygon:
for i := 0; i < g.NumLinearRings(); i++ {
isCCW := geo.IsLinearRingCCW(g.LinearRing(i))
// Interior rings should be the reverse orientation of the exterior ring.
if i > 0 {
isCCW = !isCCW
}
switch o {
case OrientationCW:
if isCCW {
return false, nil
}
case OrientationCCW:
if !isCCW {
return false, nil
}
default:
return false, errors.Newf("unexpected orientation: %v", o)
}
}
return true, nil
case *geom.MultiPolygon:
for i := 0; i < g.NumPolygons(); i++ {
if ret, err := hasPolygonOrientation(g.Polygon(i), o); !ret || err != nil {
return ret, err
}
}
return true, nil
case *geom.GeometryCollection:
for i := 0; i < g.NumGeoms(); i++ {
if ret, err := hasPolygonOrientation(g.Geom(i), o); !ret || err != nil {
return ret, err
}
}
return true, nil
case *geom.Point, *geom.MultiPoint, *geom.LineString, *geom.MultiLineString:
return true, nil
default:
return false, errors.Newf("unhandled geometry type: %T", g)
}
}
// ForcePolygonOrientation forces orientations within polygons
// to be oriented the prescribed way.
func ForcePolygonOrientation(g geo.Geometry, o Orientation) (geo.Geometry, error) {
t, err := g.AsGeomT()
if err != nil {
return geo.Geometry{}, err
}
if err := forcePolygonOrientation(t, o); err != nil {
return geo.Geometry{}, err
}
return geo.MakeGeometryFromGeomT(t)
}
func forcePolygonOrientation(g geom.T, o Orientation) error {
switch g := g.(type) {
case *geom.Polygon:
for i := 0; i < g.NumLinearRings(); i++ {
isCCW := geo.IsLinearRingCCW(g.LinearRing(i))
// Interior rings should be the reverse orientation of the exterior ring.
if i > 0 {
isCCW = !isCCW
}
reverse := false
switch o {
case OrientationCW:
if isCCW {
reverse = true
}
case OrientationCCW:
if !isCCW {
reverse = true
}
default:
return errors.Newf("unexpected orientation: %v", o)
}
if reverse {
// Reverse coordinates from both ends.
// Do this by swapping up to the middle of the array of elements, which guarantees
// each end get swapped. This works for an odd number of elements as well as
// the middle element ends swapping with itself, which is ok.
coords := g.LinearRing(i).FlatCoords()
for cIdx := 0; cIdx < len(coords)/2; cIdx += g.Stride() {
for sIdx := 0; sIdx < g.Stride(); sIdx++ {
coords[cIdx+sIdx], coords[len(coords)-cIdx-g.Stride()+sIdx] = coords[len(coords)-cIdx-g.Stride()+sIdx], coords[cIdx+sIdx]
}
}
}
}
return nil
case *geom.MultiPolygon:
for i := 0; i < g.NumPolygons(); i++ {
if err := forcePolygonOrientation(g.Polygon(i), o); err != nil {
return err
}
}
return nil
case *geom.GeometryCollection:
for i := 0; i < g.NumGeoms(); i++ {
if err := forcePolygonOrientation(g.Geom(i), o); err != nil {
return err
}
}
return nil
case *geom.Point, *geom.MultiPoint, *geom.LineString, *geom.MultiLineString:
return nil
default:
return errors.Newf("unhandled geometry type: %T", g)
}
} | pkg/geo/geomfn/orientation.go | 0.761361 | 0.440289 | orientation.go | starcoder |
package parse
import (
"fmt"
"io"
"strings"
yaml "gopkg.in/yaml.v3"
)
type YAMLTransformer interface {
Transform(node *yaml.Node) (bool, error)
}
type YAMLDataTransformer struct{}
func (YAMLDataTransformer) Transform(node *yaml.Node) (bool, error) {
if node.Tag != "!Data" {
return false, nil
}
var query *yaml.Node
switch node.Kind {
case yaml.MappingNode:
if len(node.Content) != 2 || node.Content[0].Value != "query" {
return false, fmt.Errorf(`expected mapping-style !Data to have exactly one key, "query"`)
}
query = node.Content[1]
case yaml.SequenceNode:
if len(node.Content) != 1 {
return false, fmt.Errorf(`expected sequence-style !Data to have exactly one item`)
}
query = node.Content[0]
case yaml.ScalarNode:
query = &yaml.Node{
Kind: yaml.ScalarNode,
Value: node.Value,
}
}
// {$type: Data, query: <query>}
*node = yaml.Node{
Kind: yaml.MappingNode,
Content: []*yaml.Node{
{Kind: yaml.ScalarNode, Value: "$type"},
{Kind: yaml.ScalarNode, Value: "Data"},
{Kind: yaml.ScalarNode, Value: "query"},
query,
},
}
return true, nil
}
type YAMLSecretTransformer struct{}
func (YAMLSecretTransformer) Transform(node *yaml.Node) (bool, error) {
if node.Tag != "!Secret" {
return false, nil
}
var name *yaml.Node
switch node.Kind {
case yaml.MappingNode:
if len(node.Content) != 2 || node.Content[0].Value != "name" {
return false, fmt.Errorf(`expected mapping-style !Secret to have exactly one key, "name"`)
}
name = node.Content[1]
case yaml.SequenceNode:
if len(node.Content) != 1 {
return false, fmt.Errorf(`expected sequence-style !Secret to have exactly one item`)
}
name = node.Content[0]
case yaml.ScalarNode:
name = &yaml.Node{
Kind: yaml.ScalarNode,
Value: node.Value,
}
}
// {$type: Secret, name: <name>}
*node = yaml.Node{
Kind: yaml.MappingNode,
Content: []*yaml.Node{
{Kind: yaml.ScalarNode, Value: "$type"},
{Kind: yaml.ScalarNode, Value: "Secret"},
{Kind: yaml.ScalarNode, Value: "name"},
name,
},
}
return true, nil
}
type YAMLConnectionTransformer struct{}
func (YAMLConnectionTransformer) Transform(node *yaml.Node) (bool, error) {
if node.ShortTag() != "!Connection" {
return false, nil
}
var connectionType, name *yaml.Node
switch node.Kind {
case yaml.MappingNode:
if len(node.Content) != 4 {
return false, fmt.Errorf(`expected mapping-style !Connection to have exactly two keys, "type" and "name"`)
}
for i := 0; i < len(node.Content); i += 2 {
switch node.Content[i].Value {
case "type":
connectionType = node.Content[i+1]
case "name":
name = node.Content[i+1]
default:
return false, fmt.Errorf(`expected mapping-style !Connection to have exactly two keys, "type" and "name"`)
}
}
case yaml.SequenceNode:
if len(node.Content) != 2 {
return false, fmt.Errorf(`expected mapping-style !Connection to have exactly two items`)
}
connectionType = node.Content[0]
name = node.Content[1]
default:
return false, fmt.Errorf(`unexpected scalar value for !Connection, must be a mapping or sequence`)
}
// {$type: Connection, type: <type>, name: <name>}
*node = yaml.Node{
Kind: yaml.MappingNode,
Content: []*yaml.Node{
{Kind: yaml.ScalarNode, Value: "$type"},
{Kind: yaml.ScalarNode, Value: "Connection"},
{Kind: yaml.ScalarNode, Value: "type"},
connectionType,
{Kind: yaml.ScalarNode, Value: "name"},
name,
},
}
return true, nil
}
type YAMLOutputTransformer struct{}
func (YAMLOutputTransformer) Transform(node *yaml.Node) (bool, error) {
if node.ShortTag() != "!Output" {
return false, nil
}
var from, name *yaml.Node
switch node.Kind {
case yaml.MappingNode:
if len(node.Content) != 4 {
return false, fmt.Errorf(`expected mapping-style !Output to have exactly two keys, "from" and "name"`)
}
for i := 0; i < len(node.Content); i += 2 {
switch node.Content[i].Value {
case "from":
from = node.Content[i+1]
case "name":
name = node.Content[i+1]
default:
return false, fmt.Errorf(`expected mapping-style !Output to have exactly two keys, "from" and "name"`)
}
}
case yaml.SequenceNode:
if len(node.Content) != 2 {
return false, fmt.Errorf(`expected mapping-style !Output to have exactly two items`)
}
from = node.Content[0]
name = node.Content[1]
default:
return false, fmt.Errorf(`unexpected scalar value for !Output, must be a mapping or sequence`)
}
// {$type: Output, from: <from>, name: <name>}
*node = yaml.Node{
Kind: yaml.MappingNode,
Content: []*yaml.Node{
{Kind: yaml.ScalarNode, Value: "$type"},
{Kind: yaml.ScalarNode, Value: "Output"},
{Kind: yaml.ScalarNode, Value: "from"},
from,
{Kind: yaml.ScalarNode, Value: "name"},
name,
},
}
return true, nil
}
type YAMLParameterTransformer struct{}
func (YAMLParameterTransformer) Transform(node *yaml.Node) (bool, error) {
if node.ShortTag() != "!Parameter" {
return false, nil
}
var name *yaml.Node
switch node.Kind {
case yaml.MappingNode:
if len(node.Content) != 2 || node.Content[0].Value != "name" {
return false, fmt.Errorf(`expected mapping-style !Parameter to have exactly one key, "name"`)
}
name = node.Content[1]
case yaml.SequenceNode:
if len(node.Content) != 1 {
return false, fmt.Errorf(`expected sequence-style !Parameter to have exactly one item`)
}
name = node.Content[0]
case yaml.ScalarNode:
name = &yaml.Node{
Kind: yaml.ScalarNode,
Value: node.Value,
}
}
// {$type: Parameter, name: <name>}
*node = yaml.Node{
Kind: yaml.MappingNode,
Content: []*yaml.Node{
{Kind: yaml.ScalarNode, Value: "$type"},
{Kind: yaml.ScalarNode, Value: "Parameter"},
{Kind: yaml.ScalarNode, Value: "name"},
name,
},
}
return true, nil
}
type YAMLAnswerTransformer struct{}
func (YAMLAnswerTransformer) Transform(node *yaml.Node) (bool, error) {
if node.ShortTag() != "!Answer" {
return false, nil
}
var askRef, name *yaml.Node
switch node.Kind {
case yaml.MappingNode:
if len(node.Content) != 4 {
return false, fmt.Errorf(`expected mapping-style !Answer to have exactly two keys, "askRef" and "name"`)
}
for i := 0; i < len(node.Content); i += 2 {
switch node.Content[i].Value {
case "askRef":
askRef = node.Content[i+1]
case "name":
name = node.Content[i+1]
default:
return false, fmt.Errorf(`expected mapping-style !Answer to have exactly two keys, "askRef" and "name"`)
}
}
case yaml.SequenceNode:
if len(node.Content) != 2 {
return false, fmt.Errorf(`expected mapping-style !Answer to have exactly two items`)
}
askRef = node.Content[0]
name = node.Content[1]
default:
return false, fmt.Errorf(`unexpected scalar value for !Answer, must be a mapping or sequence`)
}
// {$type: Answer, askRef: <askRef>, name: <name>}
*node = yaml.Node{
Kind: yaml.MappingNode,
Content: []*yaml.Node{
{Kind: yaml.ScalarNode, Value: "$type"},
{Kind: yaml.ScalarNode, Value: "Answer"},
{Kind: yaml.ScalarNode, Value: "askRef"},
askRef,
{Kind: yaml.ScalarNode, Value: "name"},
name,
},
}
return true, nil
}
type YAMLInvocationTransformer struct{}
func (YAMLInvocationTransformer) Transform(node *yaml.Node) (bool, error) {
tag := node.ShortTag()
prefix := "!Fn."
if !strings.HasPrefix(tag, prefix) {
return false, nil
}
name := tag[len(prefix):]
if len(name) == 0 {
return false, fmt.Errorf(`expected function name to have the syntax !Fn.<name>`)
}
var args *yaml.Node
switch node.Kind {
case yaml.MappingNode, yaml.SequenceNode:
args = &yaml.Node{
Kind: node.Kind,
Content: node.Content,
}
case yaml.ScalarNode:
args = &yaml.Node{
Kind: yaml.SequenceNode,
Content: []*yaml.Node{
{Kind: yaml.ScalarNode, Value: node.Value},
},
}
}
// {$fn.<name>: <args>}
*node = yaml.Node{
Kind: yaml.MappingNode,
Content: []*yaml.Node{
{Kind: yaml.ScalarNode, Value: fmt.Sprintf("$fn.%s", name)},
args,
},
}
return true, nil
}
type YAMLBinaryToEncodingTransformer struct{}
func (YAMLBinaryToEncodingTransformer) Transform(node *yaml.Node) (bool, error) {
if node.ShortTag() != "!!binary" || node.Kind != yaml.ScalarNode {
return false, nil
}
// {$encoding: base64, data: <value>}
*node = yaml.Node{
Kind: yaml.MappingNode,
Content: []*yaml.Node{
{Kind: yaml.ScalarNode, Value: "$encoding"},
{Kind: yaml.ScalarNode, Value: "base64"},
{Kind: yaml.ScalarNode, Value: "data"},
{Kind: yaml.ScalarNode, Value: node.Value},
},
}
return true, nil
}
type YAMLUnknownTagTransformer struct{}
func (YAMLUnknownTagTransformer) Transform(node *yaml.Node) (bool, error) {
if tag := node.ShortTag(); tag != "" && !strings.HasPrefix(tag, "!!") {
return false, fmt.Errorf(`unknown tag %q`, node.ShortTag())
}
return false, nil
}
var YAMLTransformers = []YAMLTransformer{
YAMLDataTransformer{},
YAMLSecretTransformer{},
YAMLConnectionTransformer{},
YAMLOutputTransformer{},
YAMLParameterTransformer{},
YAMLAnswerTransformer{},
YAMLInvocationTransformer{},
YAMLBinaryToEncodingTransformer{},
YAMLUnknownTagTransformer{},
}
func ParseYAML(r io.Reader) (Tree, error) {
node := &yaml.Node{}
if err := yaml.NewDecoder(r).Decode(node); err != nil {
return nil, err
}
return ParseYAMLNode(node)
}
func ParseYAMLString(data string) (Tree, error) {
return ParseYAML(strings.NewReader(data))
}
func ParseYAMLNode(node *yaml.Node) (Tree, error) {
stack := []*yaml.Node{node}
for len(stack) > 0 {
node := stack[0]
for node.Kind == yaml.AliasNode {
node = node.Alias
}
for _, t := range YAMLTransformers {
if ok, err := t.Transform(node); err != nil {
return nil, err
} else if ok {
break
}
}
// Remove head and append children for further analysis.
stack = append(stack[1:], node.Content...)
}
var tree interface{}
if err := node.Decode(&tree); err != nil {
return nil, err
}
return Tree(tree), nil
} | pkg/expr/parse/yaml.go | 0.663887 | 0.4081 | yaml.go | starcoder |
package graph
import (
"errors"
"sync"
)
type Graph struct {
mu sync.RWMutex
nodes map[string]*Node // A map of all the nodes in this graph, indexed by their key.
}
// Initializes a new graph.
func New() *Graph {
return &Graph{nodes: map[string]*Node{}}
}
// Returns the amount of nodes contained in the graph.
func (g *Graph) Len() int {
return len(g.nodes)
}
// Creates a new node. Returns true if the node was created, false if the key is already in use.
func (g *Graph) Add(key string) bool {
// lock graph until this method is finished to prevent changes made by other goroutines
g.mu.Lock()
defer g.mu.Unlock()
if g.get(key) != nil {
return false
}
// create new node and add it to the graph
g.nodes[key] = &Node{key, map[*Node]int{}, sync.RWMutex{}}
return true
}
// Deletes the node with the specified key. Returns false if key is invalid.
func (g *Graph) Delete(key string) bool {
// lock graph until this method is finished to prevent changes made by other goroutines while this one is looping etc.
g.mu.Lock()
defer g.mu.Unlock()
// get node in question
n := g.get(key)
if n == nil {
return false
}
// iterate over neighbors, remove edges from neighboring nodes
for neighbor := range n.neighbors {
// delete edge to the to-be-deleted node
neighbor.Lock()
delete(neighbor.neighbors, n)
neighbor.Unlock()
}
// delete node
delete(g.nodes, key)
return true
}
// Returns a slice containing all nodes. The slice is empty if the graph contains no nodes.
func (g *Graph) GetAll() (all []*Node) {
g.mu.RLock()
for _, n := range g.nodes {
all = append(all, n)
}
g.mu.RUnlock()
return
}
// Returns the node with this key, or nil and an error if there is no node with this key.
func (g *Graph) Get(key string) (n *Node, err error) {
g.mu.RLock()
n = g.get(key)
g.mu.RUnlock()
if n == nil {
err = errors.New("graph: invalid key")
}
return
}
// Internal function, does NOT lock the graph, should only be used in between RLock() and RUnlock() (or Lock() and Unlock()).
func (g *Graph) get(key string) *Node {
return g.nodes[key]
}
// Creates an edge between the nodes specified by the keys. Returns false if one or both of the keys are invalid or if they are the same.
// If there already is a connection, it is overwritten with the new edge weight.
func (g *Graph) Connect(keyA string, keyB string, weight int) bool {
// reflective edges are forbidden
if keyA == keyB {
return false
}
// lock graph for reading until this method is finished to prevent changes made by other goroutines while this one is running
g.mu.RLock()
defer g.mu.RUnlock()
// get nodes and check for validity of keys
nodeA := g.get(keyA)
nodeB := g.get(keyB)
if nodeA == nil || nodeB == nil {
return false
}
// add connection to both nodes
nodeA.Lock()
nodeB.Lock()
nodeA.neighbors[nodeB] = weight
nodeB.neighbors[nodeA] = weight
nodeA.Unlock()
nodeB.Unlock()
// success
return true
}
// Removes an edge connecting the two nodes. Returns false if one or both of the keys are invalid or if they are the same.
func (g *Graph) Disconnect(keyA string, keyB string) bool {
// recursive edges are forbidden
if keyA == keyB {
return false
}
// lock graph for reading until this method is finished to prevent changes made by other goroutines while this one is running
g.mu.RLock()
defer g.mu.RUnlock()
// get nodes and check for validity of keys
nodeA := g.get(keyA)
nodeB := g.get(keyB)
if nodeA == nil || nodeB == nil {
return false
}
// delete the edge from both nodes
nodeA.Lock()
nodeB.Lock()
delete(nodeA.neighbors, nodeB)
delete(nodeB.neighbors, nodeA)
nodeA.Unlock()
nodeB.Unlock()
return true
}
// Returns true and the edge weight if there is an edge between the nodes specified by their keys. Returns false and 0 if one or both keys are invalid, if they are the same, or if there is no edge between the nodes.
func (g *Graph) Adjacent(keyA string, keyB string) (exists bool, weight int) {
// sanity check
if keyA == keyB {
return
}
g.mu.RLock()
defer g.mu.RUnlock()
nodeA := g.get(keyA)
if nodeA == nil {
return
}
nodeB := g.get(keyB)
if nodeB == nil {
return
}
nodeA.RLock()
defer nodeA.RUnlock()
nodeB.RLock()
defer nodeB.RUnlock()
// choose node with less edges (easier to find 1 in 10 than to find 1 in 100)
if len(nodeA.neighbors) < len(nodeB.neighbors) {
// iterate over it's map of edges; when the right node is found, return
for neighbor, weight := range nodeA.neighbors {
if neighbor == nodeB {
return true, weight
}
}
} else {
// iterate over it's map of edges; when the right node is found, return
for neighbor, weight := range nodeB.neighbors {
if neighbor == nodeA {
return true, weight
}
}
}
return
} | graph.go | 0.746416 | 0.432243 | graph.go | starcoder |
package trie
// Node represents each node in Trie.
type Node struct {
children map[rune]*Node // map children nodes
isLeaf bool // current node value
}
// NewNode creates a new Trie node with initialized
// children map.
func NewNode() *Node {
n := &Node{}
n.children = make(map[rune]*Node)
n.isLeaf = false
return n
}
// insert a single word at a Trie node.
func (n *Node) insert(s string) {
curr := n
for _, c := range s {
next, ok := curr.children[c]
if !ok {
next = NewNode()
curr.children[c] = next
}
curr = next
}
curr.isLeaf = true
}
// Insert zero, one or more words at a Trie node.
func (n *Node) Insert(s ...string) {
for _, ss := range s {
n.insert(ss)
}
}
// Find words at a Trie node.
func (n *Node) Find(s string) bool {
next, ok := n, false
for _, c := range s {
next, ok = next.children[c]
if !ok {
return false
}
}
return next.isLeaf
}
// Capacity returns the number of nodes in the Trie
func (n *Node) Capacity() int {
r := 0
for _, c := range n.children {
r += c.Capacity()
}
return 1 + r
}
// Size returns the number of words in the Trie
func (n *Node) Size() int {
r := 0
for _, c := range n.children {
r += c.Size()
}
if n.isLeaf {
r++
}
return r
}
// remove lazily a word from the Trie node, no node is actually removed.
func (n *Node) remove(s string) {
if len(s) == 0 {
return
}
next, ok := n, false
for _, c := range s {
next, ok = next.children[c]
if !ok {
// word cannot be found - we're done !
return
}
}
next.isLeaf = false
}
// Remove zero, one or more words lazily from the Trie, no node is actually removed.
func (n *Node) Remove(s ...string) {
for _, ss := range s {
n.remove(ss)
}
}
// Compact will remove unecessay nodes, reducing the capacity, returning true if node n itself should be removed.
func (n *Node) Compact() (remove bool) {
for r, c := range n.children {
if c.Compact() {
delete(n.children, r)
}
}
return !n.isLeaf && len(n.children) == 0
} | structure/trie/trie.go | 0.759671 | 0.46041 | trie.go | starcoder |
package ast
type expr struct{}
func (e expr) Expr() {}
// The different AST nodes available to parse.
type (
// An Identifier represents a name in the variable store; evaluates to the
// value of that variable.
Identifier struct {
expr
Value string
}
// A Number represents a number literal.
Number struct {
expr
Value float64
}
// A Boolean represents a boolean literal.
Boolean struct {
expr
Value bool
}
// A String represents a unicode string literal.
String struct {
expr
Value string
}
// Nil is the nil literal; the absence of a value.
Nil struct {
expr
}
// A List is a linked list of items.
List struct {
expr
Value []Expression
}
// A Map is a hashmap.
Map struct {
expr
Value map[Expression]Expression
}
// A Block combines multiple statements into an expression.
Block struct {
expr
Value []Statement
}
// A Prefix is a prefix operator expression, such as -5.
Prefix struct {
expr
Operator string
Right Expression
}
// An Infix is an infix operator expression, such as 1 + 2
Infix struct {
expr
Operator string
Left, Right Expression
}
// A Call calls a function with the argument. If the argument is a tuple,
// each element of the tuple is passed as a separate argument.
Call struct {
expr
Function, Argument Expression
}
// An If expression executes Consequence or Alternative based on Condition.
If struct {
expr
Condition, Consequence, Alternative Expression
}
// A MatchBranch is a condition -> body branch for use in a Match expression.
// Notice a MatchBranch isn't an Expression itself.
MatchBranch struct {
Condition, Body Expression
}
// A Match executes a different piece of code based on the input value.
Match struct {
expr
Input Expression
Branches []MatchBranch
}
// A Model expression defines a new model. Parent is another model, since
// the syntax is `model dog (name) : animal (name, "dog")`.
Model struct {
expr
Parameters, Parent Expression
}
) | ast/expressions.go | 0.710929 | 0.587144 | expressions.go | starcoder |
package physics
import "github.com/mokiat/gomath/sprec"
const driftCorrectionAmount = float32(0.01) // TODO: Configurable?
type Jacobian struct {
SlopeVelocity sprec.Vec3
SlopeAngularVelocity sprec.Vec3
}
func (j Jacobian) EffectiveVelocity(body *Body) float32 {
return sprec.Vec3Dot(j.SlopeVelocity, body.velocity) +
sprec.Vec3Dot(j.SlopeAngularVelocity, body.angularVelocity)
}
func (j Jacobian) InverseEffectiveMass(body *Body) float32 {
return sprec.Vec3Dot(j.SlopeVelocity, j.SlopeVelocity)/body.mass +
sprec.Vec3Dot(sprec.Mat3Vec3Prod(sprec.InverseMat3(body.momentOfInertia), j.SlopeAngularVelocity), j.SlopeAngularVelocity)
}
func (j Jacobian) ImpulseLambda(body *Body) float32 {
return -j.EffectiveVelocity(body) / j.InverseEffectiveMass(body)
}
func (j Jacobian) ImpulseSolution(body *Body, lambda float32) SBImpulseSolution {
return SBImpulseSolution{
Impulse: sprec.Vec3Prod(j.SlopeVelocity, lambda),
AngularImpulse: sprec.Vec3Prod(j.SlopeAngularVelocity, lambda),
}
}
func (j Jacobian) NudgeLambda(body *Body, drift float32) float32 {
return -driftCorrectionAmount * drift / j.InverseEffectiveMass(body)
}
func (j Jacobian) NudgeSolution(body *Body, lambda float32) SBNudgeSolution {
return SBNudgeSolution{
Nudge: sprec.Vec3Prod(j.SlopeVelocity, lambda),
AngularNudge: sprec.Vec3Prod(j.SlopeAngularVelocity, lambda),
}
}
type PairJacobian struct {
Primary Jacobian
Secondary Jacobian
}
func (j PairJacobian) ImpulseLambda(primary, secondary *Body) float32 {
return -j.EffectiveVelocity(primary, secondary) / j.InverseEffectiveMass(primary, secondary)
}
func (j PairJacobian) ImpulseSolution(primary, secondary *Body, lambda float32) DBImpulseSolution {
return DBImpulseSolution{
Primary: SBImpulseSolution{
Impulse: sprec.Vec3Prod(j.Primary.SlopeVelocity, lambda),
AngularImpulse: sprec.Vec3Prod(j.Primary.SlopeAngularVelocity, lambda),
},
Secondary: SBImpulseSolution{
Impulse: sprec.Vec3Prod(j.Secondary.SlopeVelocity, lambda),
AngularImpulse: sprec.Vec3Prod(j.Secondary.SlopeAngularVelocity, lambda),
},
}
}
func (j PairJacobian) NudgeLambda(primary, secondary *Body, drift float32) float32 {
return -driftCorrectionAmount * drift / j.InverseEffectiveMass(primary, secondary)
}
func (j PairJacobian) NudgeSolution(primary, secondary *Body, lambda float32) DBNudgeSolution {
return DBNudgeSolution{
Primary: SBNudgeSolution{
Nudge: sprec.Vec3Prod(j.Primary.SlopeVelocity, lambda),
AngularNudge: sprec.Vec3Prod(j.Primary.SlopeAngularVelocity, lambda),
},
Secondary: SBNudgeSolution{
Nudge: sprec.Vec3Prod(j.Secondary.SlopeVelocity, lambda),
AngularNudge: sprec.Vec3Prod(j.Secondary.SlopeAngularVelocity, lambda),
},
}
}
func (j PairJacobian) EffectiveVelocity(primary, secondary *Body) float32 {
return j.Primary.EffectiveVelocity(primary) + j.Secondary.EffectiveVelocity(secondary)
}
func (j PairJacobian) InverseEffectiveMass(primary, secondary *Body) float32 {
return j.Primary.InverseEffectiveMass(primary) + j.Secondary.InverseEffectiveMass(secondary)
} | game/physics/jacobian.go | 0.659953 | 0.65506 | jacobian.go | starcoder |
package bullet
// #cgo pkg-config: bullet
// #cgo windows LDFLAGS: -Wl,--allow-multiple-definition
// #include "bulletglue.h"
import "C"
import (
"github.com/go-gl/mathgl/mgl32"
"unsafe"
)
type BulletPhysicsIndice C.int
type BulletPhysicsSDKHandle C.plPhysicsSdkHandle
type BulletDynamicWorldHandle C.plDynamicsWorldHandle
func BulletNewPhysicsSDK() BulletPhysicsSDKHandle {
return BulletPhysicsSDKHandle(C.plNewBulletSdk())
}
func BulletNewDynamicWorld(sdk BulletPhysicsSDKHandle) BulletDynamicWorldHandle {
return BulletDynamicWorldHandle(C.plCreateDynamicsWorld(sdk))
}
func BulletSetGravity(world BulletDynamicWorldHandle, x, y, z float32) {
vec3 := Vec3ToBullet(mgl32.Vec3{x, y, z})
C.plSetGravity(world, vec3[0], vec3[1], vec3[2])
}
func BulletStepSimulation(world BulletDynamicWorldHandle, dt float64) {
C.plStepSimulation(world, C.plReal(dt))
}
func BulletDeleteDynamicWorld(world BulletDynamicWorldHandle) {
C.plDeleteDynamicsWorld(world)
}
func BulletDeletePhysicsSDK(sdk BulletPhysicsSDKHandle) {
C.plDeletePhysicsSdk(sdk)
}
// Math
type BulletVec3 C.plVector3
type BulletQuat C.plQuaternion
func Vec3ToBullet(vec mgl32.Vec3) (out BulletVec3) {
out[0] = C.plReal(float64(vec.X()))
out[1] = C.plReal(float64(vec.Y()))
out[2] = C.plReal(float64(vec.Z()))
return out
}
func vec3FromBullet(vec BulletVec3) (out mgl32.Vec3) {
out[0] = float32(vec[0])
out[1] = float32(vec[1])
out[2] = float32(vec[2])
return out
}
func quatToBullet(quat mgl32.Quat) (out BulletQuat) {
out[0] = C.plReal(float64(quat.X()))
out[1] = C.plReal(float64(quat.Y()))
out[2] = C.plReal(float64(quat.Z()))
out[3] = C.plReal(float64(quat.W))
return out
}
func quatFromBullet(quat BulletQuat) (out mgl32.Quat) {
out.V[0] = float32(quat[0])
out.V[1] = float32(quat[1])
out.V[2] = float32(quat[2])
out.W = float32(quat[3])
return out
}
func mat4ToBullet(mat mgl32.Mat4) (out [16]C.plReal) {
for x := 0; x < 16; x++ {
out[x] = C.plReal(float64(mat[x]))
}
return out
}
func mat4FromBullet(mat [16]C.plReal) (out mgl32.Mat4) {
for x := 0; x < 16; x++ {
out[x] = float32(mat[x])
}
return out
}
// RigidBody
type BulletRigidBodyHandle struct {
handle C.plRigidBodyHandle
}
func NewRigidBody(mass float32, shape BulletCollisionShapeHandle) BulletRigidBodyHandle {
body := C.plCreateRigidBody(nil, C.float(mass), shape.handle)
r := BulletRigidBodyHandle{
handle: body,
}
return r
}
type BulletCollisionShapeHandle struct {
holder interface{}
handle C.plCollisionShapeHandle
}
func (c BulletCollisionShapeHandle) AddVertex(v mgl32.Vec3) {
C.plAddVertex(c.handle, C.plReal(float64(v.X())), C.plReal(float64(v.Y())), C.plReal(float64(v.Z())))
}
func (c BulletCollisionShapeHandle) AddVertices(verts []mgl32.Vec3) {
v := make([]BulletVec3, len(verts))
for idx, r := range verts {
v[idx] = Vec3ToBullet(r)
}
C.plAddVertices(c.handle, (*C.plVector3)(unsafe.Pointer(&v[0])), C.int(len(v)))
}
func BulletNewConvexHullShape() BulletCollisionShapeHandle {
return BulletCollisionShapeHandle{
handle: C.plNewConvexHullShape(),
}
}
func BulletNewSphericalHullShape(radius float64) BulletCollisionShapeHandle {
return BulletCollisionShapeHandle{
handle: C.plNewSphereShape(C.plReal(radius)),
}
}
func BulletNewCompoundShape() BulletCollisionShapeHandle {
return BulletCollisionShapeHandle{
handle: C.plNewCompoundShape(),
}
}
func BulletNewStaticPlaneShape(plane mgl32.Vec3, constant float64) BulletCollisionShapeHandle {
p := Vec3ToBullet(plane)
return BulletCollisionShapeHandle{
handle: C.plNewStaticPlaneShape(&p[0], C.float(constant)),
}
}
func BulletNewStaticTriangleShape(indices []BulletPhysicsIndice, vertices []mgl32.Vec3, totalTriangles, totalVerts int) BulletCollisionShapeHandle {
v := make([]BulletVec3, len(vertices))
for idx, r := range vertices {
v[idx] = Vec3ToBullet(r)
}
m := C.btNewBvhTriangleIndexVertexArray((*C.int)(unsafe.Pointer(&indices[0])), (*C.plVector3)(unsafe.Pointer(&v[0])), C.int(int64(totalTriangles)), C.int(int64(totalVerts)))
return BulletCollisionShapeHandle{
holder: v,
handle: C.btNewBvhTriangleMeshShape(m),
}
}
func BulletNewBrushShape(vertices []mgl32.Vec3) BulletCollisionShapeHandle {
shape := BulletNewConvexHullShape()
shape.AddVertices(vertices)
return BulletCollisionShapeHandle{
handle: shape.handle,
}
}
func BulletAddChildToCompoundShape(parent BulletCollisionShapeHandle, s BulletCollisionShapeHandle, p mgl32.Vec3, o mgl32.Quat) {
vec := Vec3ToBullet(p)
quat := quatToBullet(o)
C.plAddChildShape(parent.handle, s.handle, &vec[0], &quat[0])
}
func BulletAddRigidBody(world BulletDynamicWorldHandle, handle BulletRigidBodyHandle) {
C.plAddRigidBody(world, handle.handle)
}
func BulletRemoveRigidBody(world BulletDynamicWorldHandle, handle BulletRigidBodyHandle) {
C.plRemoveRigidBody(world, handle.handle)
}
func BulletDeleteRigidBody(handle BulletRigidBodyHandle) {
C.plDeleteRigidBody(handle.handle)
}
func BulletGetOpenGLMatrix(handle BulletRigidBodyHandle) mgl32.Mat4 {
mat := mat4ToBullet(mgl32.Ident4())
C.plGetOpenGLMatrix(handle.handle, &mat[0])
return mat4FromBullet(mat)
}
func BulletSetOpenGLMatrix(handle BulletRigidBodyHandle, transform mgl32.Mat4) {
mat := mat4ToBullet(transform)
C.plSetOpenGLMatrix(handle.handle, &mat[0])
}
func BulletGetTranslation(handle BulletRigidBodyHandle) mgl32.Vec3 {
vec := Vec3ToBullet(mgl32.Vec3{})
C.plGetPosition(handle.handle, &vec[0])
return vec3FromBullet(vec)
}
func BulletGetOrientation(handle BulletRigidBodyHandle) mgl32.Quat {
quat := quatToBullet(mgl32.Quat{})
C.plGetOrientation(handle.handle, &quat[0])
return quatFromBullet(quat)
}
func BulletApplyImpulse(handle BulletRigidBodyHandle, impulse, localPoint mgl32.Vec3) {
i := Vec3ToBullet(impulse)
p := Vec3ToBullet(localPoint)
C.plApplyImpulse(handle.handle, &i[0], &p[0])
} | framework/physics/collision/bullet/bullet.go | 0.69285 | 0.517754 | bullet.go | starcoder |
package metric
import "time"
// Recorder record rate.
type Recorder struct {
Runner *Runner
LogType LogType
Key
}
// MakeRecorder creates a Recorder.
func MakeRecorder(logType LogType, keys []string) Recorder {
return DefaultRunner.MakeRecorder(logType, keys)
}
// MakeRecorder creates a Recorder.
func (r *Runner) MakeRecorder(logType LogType, keys []string) Recorder {
return Recorder{Runner: r, LogType: logType, Key: NewKey(keys)}
}
// PutRecord put a metric record to channel.
func (c Recorder) PutRecord(v1, v2 float64) {
if c.Checked {
c.Runner.AsyncPut(c.Key.Keys, c.LogType, v1, v2)
}
}
// RTRecorder is a Round-Time recorder 平均响应时间.
type RTRecorder struct {
Recorder
Start time.Time
}
// RT makes a RT Recorder.
func RT(keys ...string) RTRecorder { return DefaultRunner.RT(keys...) }
// RT makes a RT Recorder.
func (r *Runner) RT(keys ...string) RTRecorder {
return RTRecorder{Recorder: r.MakeRecorder(KeyRT, keys), Start: time.Now()}
}
// Record records a round-time.
func (r RTRecorder) Record() { r.RecordSince(r.Start) }
// RecordSince records a round-time since start.
func (r RTRecorder) RecordSince(start time.Time) { r.PutRecord(float64(time.Since(start))/1e6, 1) }
// QPSRecorder is a QPS recorder.
type QPSRecorder struct{ Recorder }
// QPS makes a QPS Recorder.
func QPS(keys ...string) QPSRecorder { return DefaultRunner.QPS(keys...) }
// QPS makes a QPS Recorder.
func (r *Runner) QPS(keys ...string) QPSRecorder { return QPSRecorder{r.MakeRecorder(KeyQPS, keys)} }
// Record records a request.
func (q QPSRecorder) Record(times float64) {
if times > 0 {
q.PutRecord(times, 0)
}
}
// QPS1 makes a QPS Recorder and then record a request with times 1.
func QPS1(keys ...string) { QPS(keys...).Record(1) }
// QPS1 makes a QPS Recorder and then record a request with times 1.
func (r *Runner) QPS1(keys ...string) { r.QPS(keys...).Record(1) }
// SuccessRateRecorder record success rate.
type SuccessRateRecorder struct{ Recorder }
// SuccessRate makes a SuccessRateRecorder.
func SuccessRate(keys ...string) SuccessRateRecorder { return DefaultRunner.SuccessRate(keys...) }
// SuccessRate makes a SuccessRateRecorder.
func (r *Runner) SuccessRate(keys ...string) SuccessRateRecorder {
return SuccessRateRecorder{r.MakeRecorder(KeySuccessRate, keys)}
}
// IncrSuccess increment success count.
func (c SuccessRateRecorder) IncrSuccess() { c.PutRecord(1, 0) }
// IncrTotal increment total.
func (c SuccessRateRecorder) IncrTotal() { c.PutRecord(0, 1) }
// FailRateRecorder record success rate.
type FailRateRecorder struct{ Recorder }
// FailRate creates a FailRateRecorder.
func FailRate(keys ...string) FailRateRecorder { return DefaultRunner.FailRate(keys...) }
// FailRate creates a FailRateRecorder.
func (r *Runner) FailRate(keys ...string) FailRateRecorder {
return FailRateRecorder{r.MakeRecorder(KeyFailRate, keys)}
}
// IncrFail increment success count.
func (c FailRateRecorder) IncrFail() { c.PutRecord(1, 0) }
// IncrTotal increment total.
func (c FailRateRecorder) IncrTotal() { c.PutRecord(0, 1) }
// HitRateRecorder record hit rate.
type HitRateRecorder struct{ Recorder }
// HitRate makes a HitRateRecorder.
func HitRate(keys ...string) HitRateRecorder { return DefaultRunner.HitRate(keys...) }
// HitRate makes a HitRateRecorder.
func (r *Runner) HitRate(keys ...string) HitRateRecorder {
return HitRateRecorder{r.MakeRecorder(KeyHitRate, keys)}
}
// IncrHit increment success count.
func (c HitRateRecorder) IncrHit() { c.PutRecord(1, 0) }
// IncrTotal increment total.
func (c HitRateRecorder) IncrTotal() { c.PutRecord(0, 1) }
// CurRecorder record 瞬时值(Gauge).
type CurRecorder struct{ Recorder }
// Cur makes a Cur Recorder.
func Cur(keys ...string) CurRecorder { return DefaultRunner.Cur(keys...) }
// Cur makes a Cur Recorder.
func (r *Runner) Cur(keys ...string) CurRecorder {
return CurRecorder{r.MakeRecorder(KeyCUR, keys)}
}
// Record records v1.
func (c CurRecorder) Record(v1 float64) { c.PutRecord(v1, 0) } | metric/metric.go | 0.790045 | 0.559771 | metric.go | starcoder |
package mcp
import (
"fmt"
"strings"
"sync"
)
// UniqueKey is the data structure describing a unique key.
type UniqueKey struct {
// It inherits a RWMutex, which is used to modify the metadata inside the UK struct.
sync.RWMutex
// rowID is an integer describing the row ID of the unique key.
// The row ID is a virtual concept, not the real row ID for a DB table.
// Usually it is used to locate the index in an MCP.
rowID int
// value is the real value of all the UK columns.
// The key is the column name, the value is the real value.
value map[string]interface{}
}
// NewUniqueKey creates a new unique key instance.
// the map values are cloned into the new UK instance,
// so that the further changes in the value map won't affect the values inside the UK.
func NewUniqueKey(rowID int, value map[string]interface{}) *UniqueKey {
result := &UniqueKey{
rowID: rowID,
value: make(map[string]interface{}),
}
for k, v := range value {
result.value[k] = v
}
return result
}
// GetRowID gets the row ID of the unique key.
// The row ID is a virtual concept, not the real row ID for a DB table.
// Usually it is used to locate the index in an MCP.
func (uk *UniqueKey) GetRowID() int {
uk.RLock()
defer uk.RUnlock()
return uk.rowID
}
// SetRowID sets the row ID of the unique key.
func (uk *UniqueKey) SetRowID(rowID int) {
uk.Lock()
defer uk.Unlock()
uk.rowID = rowID
}
// GetValue gets the UK value map of a unique key.
// The returned value is cloned, so that further modifications won't affect the value inside the UK.
func (uk *UniqueKey) GetValue() map[string]interface{} {
uk.RLock()
defer uk.RUnlock()
result := make(map[string]interface{})
for k, v := range uk.value {
result[k] = v
}
return result
}
// SetValue sets the UK value map.
// The input values are cloned into the UK,
// and further modifications on the input map won't affect the values inside the UK.
func (uk *UniqueKey) SetValue(value map[string]interface{}) {
uk.Lock()
defer uk.Unlock()
uk.value = make(map[string]interface{})
for k, v := range value {
uk.value[k] = v
}
}
// Clone is to clone a UK into a new one.
// So that two UK objects are not interfered with each other.
func (uk *UniqueKey) Clone() *UniqueKey {
uk.RLock()
defer uk.RUnlock()
result := &UniqueKey{
rowID: uk.rowID,
value: map[string]interface{}{},
}
for k, v := range uk.value {
result.value[k] = v
}
return result
}
// String returns the string representation of a UK.
func (uk *UniqueKey) String() string {
uk.RLock()
defer uk.RUnlock()
var b strings.Builder
fmt.Fprintf(&b, "%p: { RowID: %d, ", uk, uk.rowID)
fmt.Fprintf(&b, "Keys: ( ")
for k, v := range uk.value {
fmt.Fprintf(&b, "%s = %v; ", k, v)
}
fmt.Fprintf(&b, ") }")
return b.String()
}
// IsValueEqual tests whether two UK's value parts are equal.
func (uk *UniqueKey) IsValueEqual(otherUK *UniqueKey) bool {
if uk == nil || otherUK == nil {
return false
}
uk.RLock()
defer uk.RUnlock()
otherUK.RLock()
defer otherUK.RUnlock()
if len(uk.value) != len(otherUK.value) {
return false
}
for k, v := range uk.value {
otherV, ok := otherUK.value[k]
if !ok {
return false
}
if v != otherV {
return false
}
}
return true
} | dm/simulator/internal/mcp/uk.go | 0.590425 | 0.436982 | uk.go | starcoder |
package main
type number interface {
~int | ~int32 | ~int64 | ~float32 | ~float64 | ~uint
}
func MaxOfType0[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType10[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType11[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType12[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType13[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType14[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType15[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType16[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType17[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType18[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType19[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType20[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType21[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType22[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType23[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType24[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType25[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType26[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType27[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType28[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType29[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType30[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType31[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType32[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType33[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType34[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType35[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType36[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType37[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType38[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType39[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType40[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType41[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType42[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType43[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType44[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType45[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType46[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType47[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType48[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType49[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType50[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType51[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType52[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType53[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType54[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType55[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType56[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType57[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType58[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType59[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType60[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType61[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType62[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType63[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType64[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType65[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType66[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType67[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType68[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType69[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType70[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType71[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType72[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType73[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType74[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType75[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType76[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType77[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType78[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType79[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType80[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType81[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType82[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType83[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType84[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType85[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType86[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType87[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType88[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType89[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType90[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType91[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType92[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType93[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType94[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType95[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType96[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType97[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType98[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType99[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType100[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType101[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType102[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType103[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType104[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType105[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType106[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType107[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType108[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType109[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType110[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType111[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType112[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType113[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType114[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType115[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType116[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType117[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType118[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType119[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType120[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType121[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType122[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType123[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType124[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType125[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType126[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType127[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType128[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType129[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType130[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType131[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType132[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType133[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType134[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType135[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType136[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType137[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType138[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType139[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType140[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType141[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType142[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType143[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType144[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType145[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType146[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType147[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType148[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType149[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType150[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType151[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType152[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType153[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType154[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType155[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType156[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType157[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType158[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType159[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType160[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType161[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType162[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType163[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType164[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType165[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType166[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType167[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType168[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType169[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType170[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType171[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType172[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType173[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType174[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType175[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType176[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType177[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType178[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType179[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType180[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType181[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType182[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType183[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType184[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType185[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType186[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType187[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType188[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType189[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType190[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType191[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType192[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType193[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType194[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType195[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType196[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType197[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType198[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType199[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType200[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType201[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType202[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType203[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType204[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType205[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType206[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType207[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType208[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType209[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType210[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType211[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType212[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType213[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType214[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType215[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType216[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType217[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType218[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType219[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType220[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType221[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType222[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType223[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType224[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType225[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType226[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType227[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType228[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType229[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType230[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType231[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType232[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType233[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType234[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType235[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType236[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType237[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType238[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType239[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType240[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType241[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType242[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType243[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType244[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType245[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType246[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType247[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType248[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType249[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType250[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType251[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType252[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType253[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType254[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType255[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType256[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType257[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType258[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType259[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType260[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType261[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType262[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType263[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType264[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType265[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType266[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType267[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType268[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType269[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType270[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType271[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType272[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType273[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType274[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType275[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType276[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType277[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType278[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType279[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType280[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType281[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType282[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType283[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType284[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType285[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType286[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType287[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType288[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType289[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType290[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType291[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType292[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType293[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType294[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType295[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType296[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType297[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType298[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType299[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType300[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType301[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType302[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType303[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType304[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType305[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType306[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType307[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType308[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType309[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType310[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType311[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType312[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType313[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType314[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType315[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType316[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType317[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType318[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType319[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType320[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType321[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType322[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType323[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType324[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType325[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType326[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType327[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType328[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType329[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType330[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType331[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType332[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType333[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType334[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType335[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType336[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType337[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType338[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType339[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType340[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType341[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType342[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType343[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType344[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType345[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType346[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType347[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType348[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType349[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType350[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType351[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType352[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType353[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType354[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType355[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType356[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType357[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType358[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType359[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType360[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType361[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType362[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType363[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType364[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType365[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType366[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType367[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType368[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType369[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType370[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType371[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType372[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType373[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType374[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType375[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType376[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType377[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType378[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType379[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType380[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType381[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType382[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType383[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType384[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType385[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType386[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType387[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType388[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType389[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType390[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType391[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType392[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType393[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType394[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType395[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType396[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType397[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType398[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType399[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType400[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType401[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType402[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType403[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType404[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType405[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType406[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType407[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType408[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType409[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType410[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType411[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType412[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType413[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType414[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType415[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType416[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType417[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType418[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType419[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType420[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType421[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType422[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType423[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType424[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType425[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType426[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType427[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType428[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType429[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType430[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType431[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType432[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType433[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType434[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType435[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType436[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType437[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType438[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType439[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType440[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType441[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType442[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType443[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType444[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType445[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType446[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType447[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType448[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType449[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType450[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType451[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType452[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType453[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType454[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType455[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType456[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType457[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType458[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType459[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType460[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType461[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType462[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType463[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType464[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType465[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType466[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType467[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType468[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType469[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType470[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType471[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType472[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType473[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType474[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType475[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType476[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType477[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType478[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType479[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType480[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType481[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType482[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType483[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType484[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType485[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType486[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType487[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType488[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType489[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType490[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType491[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType492[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType493[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType494[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType495[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType496[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType497[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType498[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType499[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType500[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType501[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType502[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType503[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType504[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType505[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType506[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType507[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType508[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType509[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType510[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType511[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType512[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType513[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType514[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType515[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType516[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType517[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType518[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType519[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType520[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType521[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType522[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType523[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType524[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType525[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType526[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType527[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType528[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType529[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType530[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType531[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType532[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType533[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType534[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType535[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType536[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType537[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType538[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType539[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType540[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType541[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType542[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType543[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType544[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType545[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType546[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType547[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType548[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType549[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType550[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType551[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType552[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType553[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType554[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType555[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType556[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType557[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType558[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType559[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType560[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType561[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType562[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType563[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType564[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType565[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType566[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType567[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType568[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType569[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType570[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType571[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType572[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType573[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType574[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType575[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType576[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType577[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType578[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType579[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType580[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType581[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType582[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType583[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType584[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType585[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType586[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType587[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType588[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType589[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType590[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType591[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType592[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType593[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType594[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType595[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType596[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType597[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType598[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType599[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType600[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType601[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType602[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType603[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType604[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType605[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType606[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType607[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType608[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType609[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType610[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType611[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType612[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType613[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType614[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType615[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType616[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType617[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType618[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType619[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType620[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType621[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType622[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType623[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType624[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType625[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType626[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType627[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType628[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType629[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType630[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType631[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType632[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType633[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType634[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType635[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType636[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType637[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType638[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType639[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType640[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType641[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType642[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType643[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType644[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType645[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType646[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType647[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType648[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType649[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType650[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType651[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType652[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType653[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType654[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType655[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType656[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType657[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType658[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType659[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType660[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType661[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType662[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType663[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType664[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType665[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType666[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType667[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType668[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType669[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType670[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType671[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType672[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType673[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType674[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType675[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType676[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType677[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType678[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType679[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType680[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType681[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType682[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType683[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType684[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType685[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType686[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType687[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType688[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType689[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType690[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType691[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType692[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType693[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType694[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType695[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType696[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType697[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType698[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType699[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType700[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType701[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType702[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType703[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType704[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType705[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType706[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType707[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType708[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType709[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType710[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType711[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType712[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType713[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType714[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType715[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType716[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType717[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType718[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType719[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType720[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType721[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType722[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType723[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType724[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType725[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType726[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType727[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType728[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType729[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType730[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType731[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType732[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType733[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType734[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType735[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType736[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType737[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType738[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType739[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType740[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType741[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType742[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType743[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType744[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType745[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType746[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType747[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType748[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType749[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType750[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType751[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType752[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType753[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType754[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType755[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType756[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType757[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType758[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType759[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType760[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType761[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType762[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType763[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType764[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType765[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType766[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType767[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType768[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType769[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType770[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType771[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType772[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType773[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType774[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType775[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType776[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType777[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType778[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType779[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType780[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType781[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType782[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType783[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType784[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType785[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType786[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType787[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType788[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType789[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType790[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType791[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType792[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType793[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType794[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType795[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType796[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType797[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType798[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType799[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType800[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType801[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType802[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType803[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType804[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType805[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType806[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType807[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType808[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType809[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType810[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType811[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType812[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType813[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType814[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType815[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType816[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType817[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType818[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType819[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType820[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType821[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType822[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType823[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType824[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType825[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType826[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType827[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType828[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType829[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType830[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType831[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType832[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType833[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType834[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType835[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType836[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType837[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType838[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType839[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType840[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType841[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType842[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType843[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType844[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType845[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType846[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType847[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType848[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType849[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType850[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType851[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType852[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType853[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType854[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType855[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType856[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType857[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType858[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType859[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType860[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType861[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType862[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType863[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType864[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType865[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType866[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType867[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType868[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType869[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType870[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType871[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType872[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType873[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType874[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType875[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType876[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType877[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType878[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType879[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType880[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType881[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType882[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType883[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType884[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType885[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType886[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType887[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType888[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType889[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType890[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType891[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType892[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType893[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType894[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType895[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType896[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType897[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType898[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType899[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType900[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType901[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType902[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType903[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType904[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType905[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType906[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType907[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType908[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType909[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType910[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType911[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType912[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType913[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType914[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType915[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType916[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType917[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType918[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType919[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType920[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType921[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType922[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType923[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType924[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType925[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType926[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType927[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType928[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType929[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType930[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType931[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType932[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType933[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType934[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType935[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType936[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType937[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType938[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType939[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType940[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType941[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType942[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType943[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType944[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType945[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType946[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType947[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType948[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType949[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType950[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType951[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType952[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType953[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType954[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType955[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType956[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType957[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType958[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType959[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType960[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType961[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType962[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType963[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType964[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType965[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType966[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType967[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType968[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType969[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType970[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType971[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType972[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType973[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType974[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType975[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType976[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType977[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType978[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType979[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType980[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType981[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType982[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType983[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType984[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType985[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType986[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType987[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType988[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType989[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType990[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType991[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType992[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType993[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType994[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType995[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType996[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType997[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType998[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType999[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1000[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1001[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1002[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1003[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1004[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1005[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1006[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1007[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1008[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1009[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1010[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1011[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1012[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1013[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1014[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1015[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1016[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1017[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1018[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1019[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1020[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1021[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1022[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1023[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1024[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1025[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1026[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1027[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1028[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1029[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1030[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1031[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1032[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1033[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1034[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1035[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1036[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1037[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1038[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1039[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1040[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1041[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1042[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1043[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1044[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1045[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1046[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1047[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1048[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1049[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1050[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1051[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1052[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1053[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1054[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1055[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1056[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1057[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1058[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1059[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1060[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1061[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1062[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1063[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1064[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1065[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1066[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1067[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1068[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1069[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1070[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1071[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1072[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1073[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1074[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1075[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1076[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1077[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1078[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1079[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1080[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1081[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1082[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1083[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1084[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1085[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1086[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1087[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1088[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1089[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1090[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1091[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1092[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1093[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1094[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1095[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1096[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1097[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1098[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1099[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1100[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1101[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1102[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1103[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1104[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1105[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1106[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1107[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1108[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1109[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1110[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1111[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1112[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1113[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1114[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1115[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1116[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1117[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1118[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1119[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1120[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1121[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1122[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1123[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1124[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1125[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1126[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1127[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1128[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1129[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1130[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1131[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1132[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1133[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1134[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1135[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1136[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1137[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1138[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1139[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1140[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1141[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1142[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1143[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1144[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1145[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1146[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1147[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1148[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1149[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1150[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1151[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1152[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1153[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1154[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1155[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1156[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1157[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1158[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1159[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1160[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1161[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1162[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1163[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1164[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1165[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1166[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1167[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1168[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1169[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1170[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1171[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1172[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1173[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1174[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1175[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1176[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1177[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1178[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1179[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1180[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1181[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1182[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1183[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1184[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1185[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1186[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1187[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1188[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1189[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1190[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1191[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1192[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1193[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1194[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1195[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1196[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1197[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1198[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1199[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1200[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1201[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1202[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1203[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1204[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1205[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1206[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1207[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1208[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1209[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1210[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1211[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1212[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1213[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1214[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1215[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1216[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1217[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1218[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1219[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1220[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1221[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1222[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1223[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1224[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1225[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1226[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1227[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1228[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1229[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1230[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1231[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1232[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1233[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1234[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1235[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1236[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1237[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1238[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1239[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1240[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1241[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1242[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1243[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1244[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1245[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1246[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1247[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1248[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1249[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1250[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1251[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1252[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1253[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1254[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1255[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1256[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1257[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1258[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1259[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1260[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1261[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1262[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1263[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1264[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1265[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1266[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1267[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1268[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1269[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1270[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1271[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1272[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1273[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1274[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1275[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1276[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1277[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1278[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1279[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1280[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1281[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1282[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1283[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1284[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1285[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1286[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1287[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1288[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1289[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1290[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1291[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1292[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1293[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1294[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1295[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1296[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1297[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1298[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1299[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1300[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1301[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1302[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1303[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1304[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1305[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1306[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1307[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1308[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1309[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1310[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1311[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1312[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1313[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1314[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1315[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1316[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1317[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1318[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1319[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1320[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1321[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1322[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1323[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1324[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1325[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1326[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1327[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1328[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1329[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1330[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1331[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1332[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1333[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1334[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1335[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1336[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1337[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1338[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1339[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1340[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1341[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1342[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1343[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1344[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1345[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1346[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1347[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1348[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1349[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1350[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1351[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1352[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1353[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1354[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1355[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1356[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1357[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1358[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1359[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1360[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1361[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1362[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1363[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1364[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1365[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1366[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1367[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1368[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1369[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1370[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1371[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1372[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1373[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1374[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1375[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1376[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1377[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1378[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1379[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1380[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1381[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1382[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1383[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1384[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1385[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1386[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1387[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1388[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1389[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1390[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1391[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1392[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1393[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1394[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1395[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1396[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1397[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1398[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1399[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1400[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1401[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1402[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1403[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1404[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1405[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1406[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1407[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1408[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1409[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1410[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1411[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1412[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1413[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1414[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1415[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1416[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1417[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1418[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1419[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1420[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1421[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1422[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1423[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1424[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1425[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1426[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1427[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1428[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1429[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1430[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1431[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1432[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1433[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1434[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1435[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1436[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1437[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1438[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1439[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1440[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1441[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1442[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1443[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1444[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1445[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1446[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1447[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1448[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1449[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1450[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1451[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1452[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1453[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1454[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1455[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1456[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1457[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1458[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1459[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1460[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1461[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1462[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1463[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1464[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1465[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1466[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1467[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1468[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1469[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1470[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1471[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1472[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1473[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1474[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1475[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1476[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1477[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1478[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1479[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1480[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1481[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1482[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1483[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1484[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1485[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1486[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1487[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1488[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1489[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1490[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1491[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1492[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1493[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1494[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1495[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1496[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1497[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1498[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1499[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1500[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1501[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1502[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1503[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1504[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1505[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1506[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1507[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1508[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1509[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1510[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1511[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1512[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1513[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1514[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1515[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1516[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1517[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1518[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1519[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1520[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1521[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1522[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1523[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1524[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1525[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1526[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1527[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1528[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1529[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1530[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1531[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1532[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1533[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1534[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1535[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1536[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1537[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1538[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1539[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1540[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1541[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1542[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1543[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1544[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1545[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1546[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1547[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1548[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1549[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1550[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1551[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1552[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1553[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1554[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1555[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1556[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1557[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1558[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1559[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1560[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1561[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1562[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1563[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1564[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1565[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1566[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1567[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1568[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1569[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1570[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1571[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1572[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1573[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1574[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1575[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1576[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1577[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1578[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1579[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1580[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1581[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1582[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1583[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1584[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1585[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1586[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1587[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1588[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1589[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1590[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1591[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1592[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1593[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1594[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1595[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1596[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1597[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1598[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1599[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1600[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1601[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1602[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1603[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1604[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1605[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1606[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1607[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1608[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1609[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1610[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1611[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1612[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1613[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1614[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1615[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1616[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1617[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1618[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1619[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1620[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1621[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1622[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1623[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1624[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1625[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1626[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1627[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1628[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1629[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1630[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1631[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1632[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1633[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1634[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1635[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1636[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1637[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1638[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1639[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1640[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1641[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1642[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1643[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1644[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1645[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1646[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1647[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1648[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1649[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1650[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1651[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1652[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1653[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1654[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1655[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1656[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1657[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1658[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1659[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1660[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1661[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1662[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1663[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1664[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1665[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1666[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1667[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1668[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1669[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1670[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1671[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1672[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1673[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1674[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1675[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1676[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1677[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1678[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1679[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1680[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1681[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1682[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1683[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1684[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1685[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1686[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1687[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1688[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1689[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1690[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1691[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1692[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1693[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1694[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1695[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1696[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1697[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1698[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1699[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1700[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1701[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1702[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1703[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1704[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1705[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1706[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1707[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1708[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1709[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1710[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1711[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1712[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1713[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1714[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1715[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1716[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1717[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1718[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1719[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1720[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1721[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1722[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1723[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1724[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1725[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1726[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1727[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1728[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1729[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1730[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1731[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1732[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1733[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1734[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1735[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1736[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1737[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1738[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1739[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1740[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1741[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1742[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1743[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1744[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1745[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1746[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1747[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1748[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1749[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1750[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1751[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1752[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1753[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1754[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1755[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1756[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1757[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1758[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1759[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1760[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1761[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1762[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1763[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1764[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1765[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1766[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1767[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1768[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1769[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1770[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1771[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1772[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1773[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1774[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1775[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1776[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1777[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1778[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1779[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1780[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1781[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1782[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1783[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1784[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1785[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1786[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1787[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1788[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1789[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1790[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1791[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1792[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1793[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1794[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1795[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1796[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1797[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1798[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1799[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1800[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1801[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1802[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1803[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1804[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1805[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1806[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1807[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1808[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1809[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1810[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1811[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1812[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1813[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1814[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1815[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1816[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1817[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1818[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1819[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1820[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1821[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1822[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1823[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1824[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1825[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1826[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1827[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1828[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1829[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1830[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1831[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1832[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1833[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1834[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1835[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1836[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1837[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1838[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1839[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1840[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1841[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1842[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1843[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1844[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1845[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1846[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1847[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1848[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1849[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1850[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1851[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1852[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1853[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1854[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1855[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1856[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1857[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1858[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1859[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1860[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1861[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1862[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1863[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1864[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1865[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1866[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1867[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1868[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1869[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1870[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1871[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1872[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1873[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1874[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1875[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1876[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1877[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1878[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1879[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1880[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1881[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1882[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1883[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1884[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1885[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1886[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1887[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1888[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1889[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1890[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1891[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1892[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1893[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1894[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1895[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1896[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1897[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1898[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1899[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1900[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1901[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1902[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1903[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1904[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1905[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1906[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1907[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1908[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1909[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1910[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1911[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1912[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1913[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1914[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1915[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1916[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1917[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1918[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1919[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1920[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1921[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1922[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1923[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1924[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1925[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1926[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1927[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1928[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1929[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1930[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1931[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1932[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1933[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1934[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1935[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1936[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1937[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1938[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1939[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1940[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1941[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1942[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1943[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1944[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1945[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1946[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1947[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1948[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1949[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1950[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1951[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1952[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1953[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1954[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1955[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1956[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1957[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1958[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1959[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1960[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1961[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1962[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1963[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1964[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1965[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1966[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1967[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1968[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1969[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1970[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1971[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1972[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1973[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1974[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1975[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1976[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1977[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1978[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1979[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1980[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1981[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1982[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1983[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1984[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1985[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1986[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1987[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1988[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1989[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1990[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1991[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1992[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1993[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1994[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1995[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1996[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1997[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1998[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType1999[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2000[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2001[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2002[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2003[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2004[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2005[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2006[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2007[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2008[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2009[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2010[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2011[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2012[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2013[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2014[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2015[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2016[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2017[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2018[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2019[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2020[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2021[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2022[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2023[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2024[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2025[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2026[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2027[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2028[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2029[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2030[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2031[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2032[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2033[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2034[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2035[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2036[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2037[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2038[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2039[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2040[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2041[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2042[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2043[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2044[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2045[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2046[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2047[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2048[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2049[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2050[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2051[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2052[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2053[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2054[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2055[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2056[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2057[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2058[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2059[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2060[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2061[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2062[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2063[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2064[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2065[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2066[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2067[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2068[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2069[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2070[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2071[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2072[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2073[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2074[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2075[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2076[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2077[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2078[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2079[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2080[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2081[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2082[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2083[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2084[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2085[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2086[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2087[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2088[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2089[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2090[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2091[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2092[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2093[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2094[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2095[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2096[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2097[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2098[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2099[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2100[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2101[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2102[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2103[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2104[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2105[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2106[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2107[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2108[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2109[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2110[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2111[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2112[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2113[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2114[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2115[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2116[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2117[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2118[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2119[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2120[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2121[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2122[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2123[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2124[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2125[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2126[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2127[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2128[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2129[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2130[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2131[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2132[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2133[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2134[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2135[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2136[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2137[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2138[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2139[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2140[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2141[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2142[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2143[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2144[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2145[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2146[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2147[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2148[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2149[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2150[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2151[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2152[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2153[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2154[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2155[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2156[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2157[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2158[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2159[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2160[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2161[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2162[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2163[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2164[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2165[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2166[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2167[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2168[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2169[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2170[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2171[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2172[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2173[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2174[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2175[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2176[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2177[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2178[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2179[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2180[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2181[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2182[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2183[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2184[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2185[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2186[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2187[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2188[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2189[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2190[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2191[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2192[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2193[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2194[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2195[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2196[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2197[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2198[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2199[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2200[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2201[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2202[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2203[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2204[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2205[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2206[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2207[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2208[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2209[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2210[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2211[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2212[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2213[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2214[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2215[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2216[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2217[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2218[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2219[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2220[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2221[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2222[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2223[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2224[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2225[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2226[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2227[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2228[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2229[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2230[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2231[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2232[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2233[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2234[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2235[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2236[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2237[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2238[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2239[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2240[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2241[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2242[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2243[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2244[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2245[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2246[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2247[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2248[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2249[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2250[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2251[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2252[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2253[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2254[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2255[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2256[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2257[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2258[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2259[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2260[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2261[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2262[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2263[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2264[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2265[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2266[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2267[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2268[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2269[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2270[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2271[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2272[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2273[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2274[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2275[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2276[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2277[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2278[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2279[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2280[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2281[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2282[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2283[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2284[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2285[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2286[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2287[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2288[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2289[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2290[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2291[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2292[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2293[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2294[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2295[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2296[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2297[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2298[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2299[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2300[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2301[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2302[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2303[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2304[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2305[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2306[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2307[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2308[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2309[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2310[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2311[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2312[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2313[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2314[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2315[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2316[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2317[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2318[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2319[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2320[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2321[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2322[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2323[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2324[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2325[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2326[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2327[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2328[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2329[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2330[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2331[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2332[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2333[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2334[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2335[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2336[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2337[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2338[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2339[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2340[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2341[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2342[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2343[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2344[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2345[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2346[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2347[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2348[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2349[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2350[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2351[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2352[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2353[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2354[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2355[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2356[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2357[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2358[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2359[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2360[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2361[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2362[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2363[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2364[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2365[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2366[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2367[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2368[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2369[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2370[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2371[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2372[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2373[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2374[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2375[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2376[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2377[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2378[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2379[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2380[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2381[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2382[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2383[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2384[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2385[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2386[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2387[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2388[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2389[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2390[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2391[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2392[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2393[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2394[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2395[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2396[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2397[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2398[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2399[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2400[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2401[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2402[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2403[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2404[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2405[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2406[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2407[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2408[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2409[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2410[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2411[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2412[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2413[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2414[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2415[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2416[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2417[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2418[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2419[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2420[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2421[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2422[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2423[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2424[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2425[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2426[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2427[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2428[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2429[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2430[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2431[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2432[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2433[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2434[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2435[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2436[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2437[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2438[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2439[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2440[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2441[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2442[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2443[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2444[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2445[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2446[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2447[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2448[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2449[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2450[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2451[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2452[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2453[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2454[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2455[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2456[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2457[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2458[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2459[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2460[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2461[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2462[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2463[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2464[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2465[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2466[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2467[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2468[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2469[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2470[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2471[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2472[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2473[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2474[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2475[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2476[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2477[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2478[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2479[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2480[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2481[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2482[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2483[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2484[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2485[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2486[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2487[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2488[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2489[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2490[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2491[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2492[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2493[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2494[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2495[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2496[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2497[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2498[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2499[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2500[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2501[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2502[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2503[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2504[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2505[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2506[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2507[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2508[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2509[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2510[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2511[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2512[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2513[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2514[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2515[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2516[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2517[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2518[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2519[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2520[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2521[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2522[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2523[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2524[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2525[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2526[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2527[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2528[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2529[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2530[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2531[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2532[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2533[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2534[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2535[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2536[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2537[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2538[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2539[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2540[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2541[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2542[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2543[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2544[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2545[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2546[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2547[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2548[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2549[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2550[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2551[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2552[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2553[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2554[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2555[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2556[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2557[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2558[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2559[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2560[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2561[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2562[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2563[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2564[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2565[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2566[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2567[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2568[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2569[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2570[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2571[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2572[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2573[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2574[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2575[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2576[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2577[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2578[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2579[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2580[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2581[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2582[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2583[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2584[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2585[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2586[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2587[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2588[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2589[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2590[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2591[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2592[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2593[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2594[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2595[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2596[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2597[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2598[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2599[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2600[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2601[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2602[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2603[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2604[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2605[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2606[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2607[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2608[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2609[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2610[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2611[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2612[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2613[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2614[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2615[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2616[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2617[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2618[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2619[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2620[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2621[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2622[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2623[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2624[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2625[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2626[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2627[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2628[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2629[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2630[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2631[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2632[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2633[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2634[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2635[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2636[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2637[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2638[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2639[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2640[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2641[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2642[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2643[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2644[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2645[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2646[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2647[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2648[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2649[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2650[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2651[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2652[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2653[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2654[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2655[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2656[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2657[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2658[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2659[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2660[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2661[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2662[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2663[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2664[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2665[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2666[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2667[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2668[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2669[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2670[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2671[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2672[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2673[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2674[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2675[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2676[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2677[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2678[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2679[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2680[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2681[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2682[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2683[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2684[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2685[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2686[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2687[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2688[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2689[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2690[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2691[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2692[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2693[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2694[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2695[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2696[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2697[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2698[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2699[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2700[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2701[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2702[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2703[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2704[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2705[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2706[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2707[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2708[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2709[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2710[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2711[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2712[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2713[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2714[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2715[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2716[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2717[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2718[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2719[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2720[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2721[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2722[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2723[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2724[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2725[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2726[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2727[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2728[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2729[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2730[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2731[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2732[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2733[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2734[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2735[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2736[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2737[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2738[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2739[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2740[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2741[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2742[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2743[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2744[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2745[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2746[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2747[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2748[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2749[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2750[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2751[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2752[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2753[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2754[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2755[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2756[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2757[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2758[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2759[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2760[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2761[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2762[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2763[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2764[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2765[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2766[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2767[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2768[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2769[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2770[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2771[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2772[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2773[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2774[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2775[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2776[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2777[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2778[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2779[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2780[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2781[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2782[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2783[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2784[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2785[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2786[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2787[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2788[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2789[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2790[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2791[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2792[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2793[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2794[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2795[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2796[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2797[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2798[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2799[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2800[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2801[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2802[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2803[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2804[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2805[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2806[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2807[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2808[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2809[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2810[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2811[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2812[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2813[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2814[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2815[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2816[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2817[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2818[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2819[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2820[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2821[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2822[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2823[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2824[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2825[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2826[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2827[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2828[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2829[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2830[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2831[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2832[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2833[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2834[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2835[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2836[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2837[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2838[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2839[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2840[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2841[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2842[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2843[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2844[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2845[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2846[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2847[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2848[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2849[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2850[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2851[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2852[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2853[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2854[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2855[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2856[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2857[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2858[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2859[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2860[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2861[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2862[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2863[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2864[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2865[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2866[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2867[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2868[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2869[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2870[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2871[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2872[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2873[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2874[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2875[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2876[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2877[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2878[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2879[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2880[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2881[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2882[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2883[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2884[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2885[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2886[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2887[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2888[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2889[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2890[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2891[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2892[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2893[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2894[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2895[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2896[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2897[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2898[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2899[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2900[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2901[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2902[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2903[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2904[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2905[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2906[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2907[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2908[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2909[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2910[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2911[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2912[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2913[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2914[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2915[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2916[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2917[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2918[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2919[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2920[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2921[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2922[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2923[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2924[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2925[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2926[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2927[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2928[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2929[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2930[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2931[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2932[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2933[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2934[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2935[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2936[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2937[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2938[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2939[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2940[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2941[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2942[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2943[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2944[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2945[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2946[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2947[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2948[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2949[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2950[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2951[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2952[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2953[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2954[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2955[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2956[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2957[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2958[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2959[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2960[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2961[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2962[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2963[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2964[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2965[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2966[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2967[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2968[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2969[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2970[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2971[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2972[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2973[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2974[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2975[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2976[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2977[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2978[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2979[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2980[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2981[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2982[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2983[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2984[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2985[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2986[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2987[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2988[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2989[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2990[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2991[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2992[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2993[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2994[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2995[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2996[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2997[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2998[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType2999[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3000[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3001[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3002[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3003[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3004[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3005[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3006[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3007[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3008[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3009[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3010[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3011[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3012[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3013[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3014[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3015[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3016[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3017[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3018[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3019[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3020[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3021[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3022[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3023[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3024[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3025[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3026[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3027[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3028[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3029[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3030[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3031[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3032[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3033[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3034[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3035[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3036[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3037[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3038[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3039[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3040[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3041[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3042[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3043[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3044[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3045[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3046[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3047[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3048[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3049[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3050[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3051[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3052[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3053[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3054[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3055[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3056[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3057[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3058[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3059[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3060[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3061[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3062[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3063[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3064[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3065[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3066[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3067[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3068[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3069[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3070[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3071[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3072[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3073[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3074[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3075[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3076[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3077[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3078[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3079[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3080[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3081[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3082[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3083[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3084[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3085[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3086[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3087[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3088[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3089[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3090[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3091[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3092[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3093[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3094[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3095[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3096[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3097[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3098[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3099[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3100[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3101[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3102[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3103[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3104[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3105[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3106[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3107[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3108[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3109[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3110[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3111[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3112[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3113[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3114[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3115[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3116[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3117[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3118[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3119[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3120[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3121[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3122[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3123[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3124[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3125[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3126[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3127[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3128[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3129[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3130[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3131[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3132[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3133[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3134[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3135[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3136[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3137[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3138[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3139[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3140[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3141[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3142[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3143[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3144[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3145[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3146[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3147[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3148[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3149[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3150[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3151[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3152[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3153[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3154[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3155[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3156[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3157[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3158[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3159[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3160[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3161[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3162[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3163[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3164[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3165[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3166[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3167[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3168[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3169[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3170[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3171[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3172[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3173[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3174[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3175[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3176[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3177[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3178[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3179[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3180[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3181[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3182[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3183[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3184[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3185[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3186[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3187[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3188[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3189[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3190[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3191[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3192[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3193[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3194[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3195[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3196[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3197[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3198[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3199[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3200[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3201[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3202[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3203[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3204[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3205[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3206[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3207[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3208[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3209[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3210[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3211[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3212[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3213[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3214[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3215[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3216[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3217[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3218[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3219[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3220[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3221[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3222[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3223[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3224[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3225[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3226[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3227[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3228[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3229[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3230[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3231[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3232[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3233[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3234[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3235[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3236[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3237[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3238[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3239[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3240[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3241[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3242[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3243[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3244[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3245[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3246[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3247[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3248[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3249[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3250[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3251[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3252[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3253[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3254[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3255[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3256[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3257[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3258[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3259[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3260[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3261[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3262[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3263[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3264[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3265[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3266[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3267[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3268[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3269[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3270[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3271[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3272[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3273[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3274[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3275[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3276[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3277[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3278[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3279[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3280[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3281[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3282[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3283[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3284[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3285[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3286[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3287[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3288[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3289[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3290[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3291[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3292[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3293[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3294[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3295[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3296[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3297[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3298[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3299[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3300[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3301[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3302[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3303[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3304[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3305[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3306[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3307[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3308[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3309[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3310[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3311[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3312[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3313[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3314[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3315[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3316[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3317[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3318[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3319[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3320[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3321[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3322[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3323[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3324[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3325[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3326[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3327[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3328[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3329[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3330[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3331[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3332[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3333[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3334[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3335[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3336[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3337[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3338[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3339[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3340[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3341[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3342[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3343[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3344[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3345[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3346[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3347[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3348[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3349[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3350[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3351[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3352[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3353[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3354[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3355[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3356[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3357[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3358[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3359[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3360[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3361[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3362[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3363[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3364[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3365[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3366[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3367[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3368[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3369[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3370[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3371[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3372[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3373[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3374[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3375[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3376[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3377[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3378[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3379[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3380[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3381[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3382[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3383[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3384[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3385[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3386[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3387[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3388[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3389[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3390[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3391[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3392[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3393[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3394[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3395[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3396[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3397[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3398[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3399[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3400[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3401[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3402[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3403[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3404[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3405[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3406[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3407[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3408[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3409[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3410[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3411[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3412[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3413[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3414[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3415[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3416[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3417[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3418[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3419[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3420[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3421[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3422[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3423[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3424[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3425[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3426[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3427[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3428[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3429[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3430[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3431[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3432[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3433[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3434[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3435[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3436[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3437[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3438[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3439[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3440[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3441[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3442[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3443[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3444[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3445[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3446[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3447[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3448[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3449[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3450[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3451[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3452[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3453[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3454[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3455[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3456[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3457[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3458[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3459[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3460[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3461[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3462[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3463[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3464[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3465[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3466[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3467[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3468[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3469[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3470[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3471[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3472[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3473[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3474[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3475[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3476[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3477[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3478[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3479[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3480[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3481[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3482[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3483[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3484[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3485[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3486[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3487[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3488[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3489[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3490[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3491[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3492[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3493[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3494[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3495[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3496[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3497[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3498[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3499[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3500[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3501[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3502[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3503[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3504[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3505[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3506[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3507[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3508[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3509[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3510[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3511[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3512[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3513[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3514[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3515[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3516[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3517[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3518[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3519[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3520[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3521[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3522[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3523[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3524[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3525[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3526[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3527[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3528[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3529[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3530[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3531[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3532[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3533[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3534[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3535[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3536[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3537[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3538[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3539[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3540[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3541[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3542[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3543[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3544[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3545[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3546[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3547[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3548[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3549[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3550[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3551[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3552[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3553[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3554[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3555[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3556[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3557[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3558[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3559[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3560[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3561[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3562[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3563[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3564[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3565[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3566[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3567[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3568[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3569[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3570[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3571[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3572[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3573[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3574[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3575[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3576[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3577[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3578[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3579[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3580[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3581[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3582[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3583[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3584[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3585[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3586[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3587[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3588[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3589[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3590[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3591[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3592[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3593[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3594[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3595[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3596[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3597[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3598[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3599[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3600[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3601[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3602[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3603[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3604[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3605[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3606[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3607[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3608[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3609[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3610[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3611[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3612[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3613[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3614[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3615[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3616[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3617[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3618[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3619[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3620[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3621[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3622[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3623[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3624[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3625[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3626[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3627[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3628[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3629[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3630[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3631[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3632[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3633[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3634[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3635[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3636[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3637[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3638[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3639[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3640[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3641[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3642[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3643[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3644[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3645[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3646[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3647[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3648[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3649[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3650[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3651[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3652[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3653[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3654[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3655[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3656[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3657[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3658[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3659[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3660[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3661[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3662[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3663[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3664[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3665[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3666[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3667[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3668[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3669[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3670[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3671[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3672[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3673[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3674[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3675[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3676[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3677[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3678[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3679[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3680[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3681[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3682[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3683[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3684[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3685[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3686[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3687[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3688[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3689[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3690[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3691[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3692[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3693[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3694[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3695[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3696[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3697[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3698[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3699[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3700[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3701[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3702[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3703[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3704[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3705[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3706[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3707[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3708[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3709[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3710[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3711[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3712[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3713[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3714[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3715[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3716[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3717[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3718[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3719[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3720[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3721[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3722[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3723[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3724[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3725[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3726[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3727[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3728[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3729[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3730[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3731[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3732[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3733[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3734[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3735[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3736[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3737[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3738[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3739[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3740[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3741[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3742[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3743[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3744[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3745[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3746[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3747[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3748[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3749[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3750[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3751[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3752[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3753[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3754[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3755[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3756[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3757[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3758[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3759[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3760[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3761[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3762[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3763[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3764[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3765[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3766[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3767[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3768[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3769[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3770[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3771[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3772[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3773[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3774[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3775[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3776[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3777[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3778[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3779[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3780[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3781[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3782[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3783[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3784[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3785[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3786[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3787[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3788[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3789[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3790[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3791[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3792[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3793[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3794[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3795[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3796[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3797[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3798[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3799[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3800[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3801[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3802[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3803[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3804[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3805[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3806[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3807[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3808[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3809[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3810[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3811[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3812[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3813[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3814[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3815[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3816[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3817[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3818[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3819[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3820[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3821[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3822[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3823[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3824[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3825[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3826[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3827[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3828[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3829[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3830[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3831[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3832[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3833[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3834[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3835[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3836[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3837[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3838[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3839[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3840[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3841[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3842[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3843[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3844[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3845[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3846[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3847[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3848[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3849[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3850[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3851[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3852[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3853[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3854[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3855[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3856[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3857[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3858[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3859[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3860[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3861[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3862[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3863[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3864[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3865[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3866[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3867[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3868[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3869[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3870[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3871[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3872[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3873[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3874[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3875[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3876[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3877[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3878[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3879[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3880[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3881[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3882[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3883[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3884[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3885[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3886[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3887[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3888[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3889[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3890[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3891[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3892[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3893[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3894[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3895[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3896[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3897[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3898[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3899[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3900[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3901[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3902[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3903[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3904[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3905[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3906[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3907[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3908[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3909[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3910[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3911[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3912[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3913[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3914[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3915[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3916[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3917[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3918[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3919[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3920[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3921[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3922[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3923[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3924[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3925[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3926[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3927[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3928[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3929[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3930[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3931[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3932[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3933[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3934[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3935[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3936[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3937[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3938[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3939[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3940[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3941[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3942[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3943[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3944[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3945[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3946[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3947[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3948[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3949[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3950[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3951[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3952[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3953[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3954[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3955[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3956[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3957[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3958[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3959[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3960[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3961[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3962[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3963[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3964[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3965[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3966[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3967[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3968[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3969[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3970[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3971[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3972[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3973[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3974[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3975[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3976[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3977[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3978[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3979[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3980[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3981[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3982[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3983[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3984[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3985[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3986[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3987[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3988[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3989[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3990[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3991[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3992[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3993[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3994[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3995[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3996[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3997[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3998[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType3999[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4000[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4001[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4002[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4003[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4004[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4005[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4006[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4007[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4008[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4009[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4010[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4011[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4012[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4013[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4014[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4015[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4016[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4017[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4018[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4019[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4020[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4021[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4022[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4023[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4024[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4025[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4026[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4027[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4028[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4029[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4030[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4031[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4032[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4033[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4034[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4035[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4036[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4037[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4038[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4039[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4040[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4041[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4042[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4043[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4044[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4045[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4046[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4047[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4048[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4049[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4050[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4051[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4052[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4053[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4054[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4055[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4056[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4057[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4058[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4059[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4060[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4061[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4062[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4063[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4064[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4065[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4066[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4067[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4068[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4069[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4070[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4071[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4072[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4073[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4074[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4075[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4076[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4077[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4078[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4079[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4080[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4081[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4082[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4083[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4084[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4085[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4086[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4087[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4088[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4089[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4090[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4091[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4092[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4093[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4094[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4095[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4096[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4097[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4098[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4099[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4100[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4101[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4102[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4103[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4104[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4105[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4106[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4107[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4108[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4109[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4110[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4111[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4112[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4113[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4114[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4115[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4116[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4117[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4118[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4119[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4120[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4121[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4122[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4123[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4124[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4125[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4126[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4127[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4128[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4129[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4130[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4131[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4132[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4133[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4134[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4135[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4136[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4137[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4138[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4139[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4140[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4141[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4142[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4143[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4144[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4145[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4146[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4147[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4148[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4149[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4150[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4151[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4152[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4153[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4154[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4155[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4156[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4157[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4158[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4159[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4160[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4161[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4162[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4163[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4164[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4165[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4166[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4167[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4168[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4169[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4170[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4171[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4172[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4173[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4174[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4175[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4176[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4177[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4178[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4179[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4180[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4181[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4182[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4183[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4184[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4185[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4186[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4187[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4188[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4189[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4190[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4191[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4192[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4193[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4194[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4195[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4196[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4197[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4198[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4199[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4200[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4201[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4202[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4203[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4204[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4205[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4206[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4207[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4208[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4209[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4210[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4211[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4212[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4213[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4214[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4215[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4216[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4217[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4218[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4219[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4220[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4221[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4222[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4223[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4224[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4225[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4226[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4227[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4228[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4229[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4230[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4231[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4232[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4233[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4234[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4235[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4236[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4237[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4238[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4239[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4240[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4241[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4242[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4243[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4244[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4245[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4246[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4247[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4248[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4249[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4250[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4251[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4252[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4253[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4254[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4255[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4256[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4257[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4258[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4259[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4260[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4261[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4262[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4263[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4264[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4265[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4266[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4267[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4268[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4269[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4270[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4271[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4272[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4273[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4274[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4275[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4276[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4277[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4278[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4279[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4280[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4281[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4282[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4283[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4284[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4285[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4286[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4287[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4288[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4289[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4290[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4291[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4292[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4293[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4294[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4295[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4296[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4297[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4298[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4299[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4300[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4301[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4302[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4303[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4304[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4305[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4306[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4307[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4308[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4309[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4310[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4311[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4312[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4313[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4314[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4315[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4316[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4317[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4318[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4319[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4320[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4321[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4322[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4323[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4324[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4325[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4326[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4327[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4328[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4329[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4330[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4331[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4332[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4333[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4334[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4335[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4336[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4337[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4338[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4339[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4340[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4341[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4342[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4343[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4344[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4345[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4346[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4347[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4348[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4349[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4350[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4351[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4352[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4353[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4354[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4355[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4356[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4357[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4358[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4359[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4360[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4361[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4362[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4363[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4364[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4365[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4366[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4367[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4368[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4369[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4370[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4371[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4372[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4373[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4374[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4375[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4376[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4377[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4378[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4379[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4380[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4381[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4382[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4383[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4384[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4385[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4386[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4387[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4388[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4389[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4390[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4391[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4392[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4393[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4394[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4395[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4396[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4397[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4398[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4399[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4400[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4401[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4402[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4403[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4404[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4405[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4406[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4407[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4408[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4409[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4410[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4411[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4412[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4413[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4414[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4415[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4416[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4417[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4418[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4419[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4420[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4421[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4422[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4423[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4424[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4425[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4426[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4427[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4428[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4429[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4430[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4431[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4432[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4433[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4434[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4435[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4436[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4437[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4438[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4439[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4440[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4441[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4442[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4443[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4444[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4445[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4446[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4447[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4448[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4449[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4450[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4451[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4452[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4453[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4454[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4455[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4456[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4457[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4458[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4459[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4460[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4461[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4462[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4463[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4464[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4465[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4466[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4467[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4468[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4469[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4470[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4471[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4472[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4473[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4474[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4475[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4476[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4477[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4478[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4479[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4480[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4481[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4482[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4483[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4484[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4485[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4486[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4487[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4488[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4489[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4490[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4491[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4492[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4493[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4494[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4495[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4496[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4497[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4498[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4499[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4500[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4501[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4502[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4503[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4504[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4505[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4506[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4507[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4508[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4509[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4510[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4511[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4512[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4513[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4514[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4515[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4516[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4517[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4518[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4519[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4520[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4521[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4522[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4523[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4524[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4525[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4526[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4527[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4528[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4529[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4530[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4531[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4532[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4533[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4534[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4535[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4536[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4537[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4538[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4539[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4540[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4541[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4542[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4543[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4544[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4545[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4546[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4547[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4548[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4549[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4550[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4551[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4552[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4553[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4554[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4555[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4556[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4557[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4558[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4559[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4560[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4561[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4562[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4563[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4564[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4565[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4566[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4567[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4568[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4569[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4570[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4571[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4572[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4573[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4574[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4575[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4576[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4577[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4578[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4579[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4580[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4581[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4582[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4583[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4584[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4585[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4586[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4587[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4588[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4589[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4590[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4591[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4592[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4593[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4594[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4595[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4596[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4597[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4598[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4599[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4600[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4601[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4602[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4603[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4604[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4605[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4606[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4607[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4608[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4609[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4610[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4611[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4612[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4613[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4614[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4615[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4616[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4617[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4618[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4619[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4620[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4621[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4622[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4623[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4624[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4625[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4626[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4627[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4628[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4629[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4630[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4631[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4632[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4633[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4634[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4635[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4636[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4637[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4638[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4639[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4640[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4641[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4642[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4643[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4644[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4645[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4646[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4647[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4648[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4649[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4650[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4651[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4652[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4653[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4654[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4655[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4656[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4657[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4658[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4659[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4660[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4661[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4662[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4663[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4664[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4665[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4666[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4667[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4668[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4669[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4670[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4671[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4672[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4673[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4674[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4675[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4676[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4677[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4678[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4679[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4680[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4681[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4682[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4683[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4684[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4685[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4686[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4687[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4688[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4689[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4690[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4691[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4692[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4693[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4694[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4695[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4696[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4697[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4698[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4699[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4700[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4701[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4702[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4703[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4704[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4705[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4706[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4707[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4708[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4709[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4710[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4711[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4712[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4713[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4714[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4715[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4716[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4717[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4718[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4719[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4720[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4721[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4722[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4723[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4724[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4725[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4726[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4727[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4728[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4729[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4730[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4731[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4732[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4733[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4734[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4735[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4736[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4737[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4738[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4739[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4740[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4741[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4742[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4743[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4744[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4745[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4746[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4747[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4748[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4749[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4750[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4751[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4752[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4753[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4754[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4755[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4756[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4757[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4758[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4759[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4760[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4761[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4762[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4763[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4764[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4765[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4766[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4767[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4768[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4769[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4770[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4771[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4772[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4773[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4774[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4775[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4776[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4777[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4778[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4779[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4780[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4781[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4782[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4783[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4784[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4785[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4786[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4787[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4788[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4789[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4790[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4791[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4792[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4793[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4794[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4795[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4796[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4797[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4798[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4799[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4800[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4801[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4802[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4803[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4804[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4805[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4806[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4807[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4808[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4809[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4810[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4811[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4812[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4813[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4814[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4815[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4816[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4817[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4818[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4819[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4820[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4821[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4822[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4823[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4824[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4825[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4826[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4827[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4828[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4829[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4830[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4831[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4832[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4833[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4834[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4835[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4836[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4837[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4838[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4839[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4840[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4841[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4842[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4843[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4844[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4845[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4846[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4847[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4848[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4849[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4850[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4851[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4852[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4853[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4854[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4855[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4856[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4857[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4858[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4859[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4860[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4861[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4862[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4863[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4864[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4865[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4866[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4867[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4868[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4869[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4870[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4871[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4872[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4873[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4874[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4875[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4876[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4877[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4878[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4879[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4880[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4881[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4882[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4883[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4884[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4885[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4886[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4887[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4888[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4889[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4890[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4891[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4892[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4893[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4894[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4895[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4896[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4897[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4898[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4899[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4900[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4901[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4902[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4903[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4904[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4905[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4906[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4907[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4908[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4909[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4910[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4911[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4912[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4913[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4914[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4915[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4916[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4917[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4918[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4919[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4920[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4921[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4922[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4923[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4924[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4925[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4926[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4927[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4928[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4929[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4930[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4931[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4932[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4933[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4934[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4935[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4936[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4937[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4938[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4939[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4940[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4941[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4942[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4943[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4944[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4945[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4946[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4947[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4948[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4949[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4950[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4951[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4952[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4953[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4954[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4955[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4956[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4957[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4958[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4959[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4960[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4961[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4962[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4963[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4964[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4965[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4966[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4967[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4968[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4969[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4970[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4971[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4972[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4973[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4974[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4975[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4976[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4977[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4978[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4979[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4980[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4981[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4982[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4983[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4984[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4985[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4986[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4987[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4988[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4989[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4990[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4991[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4992[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4993[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4994[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4995[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4996[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4997[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4998[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType4999[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5000[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5001[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5002[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5003[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5004[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5005[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5006[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5007[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5008[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5009[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5010[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5011[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5012[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5013[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5014[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5015[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5016[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5017[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5018[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5019[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5020[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5021[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5022[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5023[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5024[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5025[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5026[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5027[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5028[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5029[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5030[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5031[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5032[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5033[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5034[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5035[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5036[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5037[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5038[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5039[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5040[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5041[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5042[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5043[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5044[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5045[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5046[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5047[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5048[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5049[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5050[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5051[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5052[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5053[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5054[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5055[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5056[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5057[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5058[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5059[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5060[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5061[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5062[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5063[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5064[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5065[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5066[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5067[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5068[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5069[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5070[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5071[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5072[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5073[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5074[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5075[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5076[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5077[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5078[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5079[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5080[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5081[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5082[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5083[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5084[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5085[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5086[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5087[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5088[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5089[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5090[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5091[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5092[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5093[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5094[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5095[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5096[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5097[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5098[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5099[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5100[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5101[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5102[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5103[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5104[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5105[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5106[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5107[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5108[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5109[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5110[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5111[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5112[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5113[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5114[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5115[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5116[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5117[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5118[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5119[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5120[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5121[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5122[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5123[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5124[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5125[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5126[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5127[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5128[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5129[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5130[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5131[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5132[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5133[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5134[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5135[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5136[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5137[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5138[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5139[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5140[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5141[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5142[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5143[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5144[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5145[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5146[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5147[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5148[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5149[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5150[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5151[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5152[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5153[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5154[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5155[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5156[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5157[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5158[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5159[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5160[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5161[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5162[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5163[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5164[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5165[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5166[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5167[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5168[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5169[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5170[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5171[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5172[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5173[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5174[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5175[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5176[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5177[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5178[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5179[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5180[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5181[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5182[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5183[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5184[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5185[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5186[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5187[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5188[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5189[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5190[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5191[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5192[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5193[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5194[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5195[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5196[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5197[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5198[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5199[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5200[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5201[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5202[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5203[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5204[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5205[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5206[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5207[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5208[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5209[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5210[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5211[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5212[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5213[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5214[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5215[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5216[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5217[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5218[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5219[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5220[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5221[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5222[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5223[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5224[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5225[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5226[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5227[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5228[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5229[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5230[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5231[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5232[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5233[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5234[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5235[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5236[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5237[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5238[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5239[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5240[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5241[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5242[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5243[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5244[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5245[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5246[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5247[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5248[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5249[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5250[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5251[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5252[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5253[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5254[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5255[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5256[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5257[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5258[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5259[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5260[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5261[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5262[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5263[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5264[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5265[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5266[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5267[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5268[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5269[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5270[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5271[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5272[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5273[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5274[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5275[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5276[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5277[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5278[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5279[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5280[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5281[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5282[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5283[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5284[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5285[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5286[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5287[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5288[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5289[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5290[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5291[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5292[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5293[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5294[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5295[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5296[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5297[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5298[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5299[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5300[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5301[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5302[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5303[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5304[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5305[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5306[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5307[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5308[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5309[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5310[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5311[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5312[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5313[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5314[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5315[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5316[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5317[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5318[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5319[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5320[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5321[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5322[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5323[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5324[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5325[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5326[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5327[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5328[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5329[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5330[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5331[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5332[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5333[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5334[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5335[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5336[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5337[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5338[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5339[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5340[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5341[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5342[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5343[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5344[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5345[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5346[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5347[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5348[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5349[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5350[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5351[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5352[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5353[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5354[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5355[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5356[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5357[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5358[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5359[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5360[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5361[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5362[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5363[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5364[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5365[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5366[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5367[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5368[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5369[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5370[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5371[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5372[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5373[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5374[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5375[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5376[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5377[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5378[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5379[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5380[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5381[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5382[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5383[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5384[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5385[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5386[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5387[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5388[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5389[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5390[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5391[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5392[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5393[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5394[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5395[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5396[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5397[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5398[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5399[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5400[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5401[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5402[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5403[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5404[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5405[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5406[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5407[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5408[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5409[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5410[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5411[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5412[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5413[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5414[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5415[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5416[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5417[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5418[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5419[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5420[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5421[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5422[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5423[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5424[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5425[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5426[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5427[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5428[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5429[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5430[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5431[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5432[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5433[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5434[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5435[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5436[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5437[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5438[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5439[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5440[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5441[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5442[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5443[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5444[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5445[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5446[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5447[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5448[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5449[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5450[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5451[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5452[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5453[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5454[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5455[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5456[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5457[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5458[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5459[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5460[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5461[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5462[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5463[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5464[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5465[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5466[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5467[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5468[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5469[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5470[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5471[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5472[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5473[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5474[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5475[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5476[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5477[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5478[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5479[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5480[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5481[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5482[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5483[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5484[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5485[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5486[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5487[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5488[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5489[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5490[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5491[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5492[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5493[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5494[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5495[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5496[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5497[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5498[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5499[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5500[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5501[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5502[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5503[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5504[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5505[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5506[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5507[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5508[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5509[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5510[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5511[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5512[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5513[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5514[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5515[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5516[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5517[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5518[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5519[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5520[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5521[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5522[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5523[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5524[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5525[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5526[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5527[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5528[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5529[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5530[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5531[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5532[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5533[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5534[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5535[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5536[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5537[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5538[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5539[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5540[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5541[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5542[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5543[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5544[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5545[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5546[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5547[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5548[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5549[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5550[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5551[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5552[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5553[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5554[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5555[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5556[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5557[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5558[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5559[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5560[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5561[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5562[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5563[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5564[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5565[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5566[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5567[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5568[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5569[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5570[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5571[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5572[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5573[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5574[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5575[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5576[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5577[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5578[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5579[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5580[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5581[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5582[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5583[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5584[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5585[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5586[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5587[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5588[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5589[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5590[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5591[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5592[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5593[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5594[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5595[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5596[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5597[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5598[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5599[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5600[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5601[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5602[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5603[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5604[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5605[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5606[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5607[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5608[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5609[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5610[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5611[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5612[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5613[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5614[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5615[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5616[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5617[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5618[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5619[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5620[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5621[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5622[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5623[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5624[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5625[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5626[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5627[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5628[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5629[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5630[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5631[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5632[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5633[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5634[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5635[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5636[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5637[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5638[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5639[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5640[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5641[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5642[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5643[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5644[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5645[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5646[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5647[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5648[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5649[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5650[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5651[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5652[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5653[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5654[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5655[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5656[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5657[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5658[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5659[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5660[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5661[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5662[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5663[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5664[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5665[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5666[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5667[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5668[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5669[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5670[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5671[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5672[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5673[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5674[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5675[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5676[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5677[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5678[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5679[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5680[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5681[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5682[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5683[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5684[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5685[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5686[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5687[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5688[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5689[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5690[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5691[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5692[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5693[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5694[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5695[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5696[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5697[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5698[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5699[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5700[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5701[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5702[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5703[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5704[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5705[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5706[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5707[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5708[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5709[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5710[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5711[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5712[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5713[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5714[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5715[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5716[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5717[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5718[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5719[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5720[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5721[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5722[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5723[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5724[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5725[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5726[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5727[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5728[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5729[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5730[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5731[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5732[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5733[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5734[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5735[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5736[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5737[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5738[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5739[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5740[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5741[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5742[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5743[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5744[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5745[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5746[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5747[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5748[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5749[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5750[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5751[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5752[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5753[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5754[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5755[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5756[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5757[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5758[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5759[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5760[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5761[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5762[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5763[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5764[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5765[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5766[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5767[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5768[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5769[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5770[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5771[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5772[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5773[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5774[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5775[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5776[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5777[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5778[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5779[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5780[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5781[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5782[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5783[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5784[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5785[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5786[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5787[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5788[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5789[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5790[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5791[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5792[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5793[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5794[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5795[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5796[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5797[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5798[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5799[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5800[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5801[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5802[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5803[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5804[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5805[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5806[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5807[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5808[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5809[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5810[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5811[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5812[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5813[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5814[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5815[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5816[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5817[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5818[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5819[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5820[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5821[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5822[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5823[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5824[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5825[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5826[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5827[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5828[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5829[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5830[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5831[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5832[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5833[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5834[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5835[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5836[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5837[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5838[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5839[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5840[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5841[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5842[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5843[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5844[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5845[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5846[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5847[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5848[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5849[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5850[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5851[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5852[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5853[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5854[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5855[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5856[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5857[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5858[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5859[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5860[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5861[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5862[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5863[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5864[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5865[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5866[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5867[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5868[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5869[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5870[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5871[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5872[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5873[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5874[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5875[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5876[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5877[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5878[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5879[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5880[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5881[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5882[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5883[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5884[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5885[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5886[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5887[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5888[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5889[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5890[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5891[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5892[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5893[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5894[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5895[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5896[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5897[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5898[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5899[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5900[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5901[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5902[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5903[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5904[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5905[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5906[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5907[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5908[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5909[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5910[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5911[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5912[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5913[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5914[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5915[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5916[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5917[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5918[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5919[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5920[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5921[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5922[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5923[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5924[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5925[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5926[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5927[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5928[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5929[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5930[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5931[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5932[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5933[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5934[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5935[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5936[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5937[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5938[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5939[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5940[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5941[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5942[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5943[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5944[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5945[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5946[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5947[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5948[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5949[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5950[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5951[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5952[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5953[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5954[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5955[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5956[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5957[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5958[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5959[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5960[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5961[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5962[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5963[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5964[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5965[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5966[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5967[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5968[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5969[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5970[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5971[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5972[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5973[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5974[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5975[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5976[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5977[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5978[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5979[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5980[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5981[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5982[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5983[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5984[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5985[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5986[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5987[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5988[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5989[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5990[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5991[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5992[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5993[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5994[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5995[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5996[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5997[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5998[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType5999[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6000[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6001[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6002[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6003[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6004[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6005[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6006[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6007[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6008[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6009[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6010[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6011[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6012[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6013[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6014[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6015[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6016[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6017[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6018[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6019[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6020[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6021[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6022[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6023[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6024[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6025[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6026[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6027[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6028[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6029[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6030[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6031[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6032[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6033[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6034[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6035[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6036[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6037[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6038[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6039[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6040[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6041[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6042[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6043[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6044[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6045[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6046[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6047[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6048[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6049[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6050[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6051[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6052[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6053[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6054[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6055[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6056[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6057[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6058[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6059[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6060[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6061[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6062[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6063[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6064[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6065[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6066[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6067[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6068[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6069[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6070[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6071[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6072[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6073[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6074[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6075[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6076[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6077[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6078[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6079[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6080[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6081[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6082[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6083[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6084[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6085[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6086[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6087[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6088[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6089[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6090[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6091[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6092[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6093[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6094[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6095[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6096[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6097[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6098[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6099[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6100[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6101[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6102[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6103[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6104[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6105[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6106[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6107[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6108[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6109[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6110[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6111[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6112[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6113[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6114[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6115[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6116[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6117[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6118[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6119[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6120[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6121[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6122[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6123[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6124[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6125[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6126[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6127[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6128[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6129[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6130[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6131[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6132[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6133[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6134[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6135[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6136[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6137[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6138[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6139[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6140[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6141[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6142[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6143[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6144[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6145[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6146[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6147[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6148[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6149[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6150[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6151[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6152[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6153[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6154[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6155[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6156[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6157[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6158[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6159[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6160[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6161[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6162[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6163[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6164[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6165[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6166[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6167[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6168[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6169[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6170[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6171[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6172[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6173[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6174[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6175[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6176[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6177[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6178[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6179[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6180[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6181[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6182[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6183[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6184[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6185[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6186[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6187[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6188[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6189[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6190[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6191[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6192[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6193[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6194[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6195[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6196[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6197[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6198[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6199[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6200[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6201[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6202[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6203[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6204[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6205[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6206[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6207[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6208[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6209[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6210[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6211[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6212[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6213[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6214[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6215[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6216[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6217[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6218[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6219[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6220[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6221[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6222[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6223[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6224[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6225[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6226[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6227[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6228[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6229[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6230[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6231[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6232[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6233[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6234[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6235[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6236[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6237[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6238[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6239[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6240[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6241[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6242[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6243[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6244[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6245[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6246[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6247[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6248[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6249[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6250[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6251[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6252[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6253[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6254[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6255[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6256[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6257[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6258[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6259[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6260[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6261[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6262[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6263[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6264[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6265[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6266[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6267[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6268[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6269[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6270[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6271[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6272[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6273[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6274[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6275[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6276[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6277[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6278[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6279[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6280[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6281[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6282[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6283[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6284[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6285[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6286[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6287[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6288[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6289[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6290[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6291[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6292[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6293[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6294[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6295[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6296[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6297[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6298[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6299[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6300[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6301[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6302[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6303[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6304[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6305[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6306[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6307[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6308[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6309[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6310[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6311[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6312[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6313[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6314[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6315[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6316[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6317[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6318[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6319[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6320[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6321[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6322[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6323[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6324[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6325[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6326[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6327[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6328[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6329[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6330[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6331[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6332[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6333[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6334[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6335[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6336[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6337[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6338[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6339[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6340[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6341[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6342[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6343[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6344[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6345[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6346[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6347[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6348[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6349[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6350[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6351[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6352[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6353[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6354[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6355[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6356[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6357[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6358[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6359[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6360[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6361[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6362[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6363[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6364[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6365[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6366[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6367[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6368[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6369[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6370[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6371[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6372[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6373[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6374[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6375[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6376[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6377[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6378[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6379[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6380[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6381[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6382[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6383[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6384[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6385[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6386[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6387[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6388[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6389[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6390[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6391[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6392[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6393[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6394[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6395[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6396[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6397[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6398[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6399[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6400[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6401[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6402[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6403[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6404[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6405[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6406[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6407[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6408[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6409[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6410[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6411[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6412[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6413[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6414[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6415[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6416[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6417[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6418[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6419[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6420[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6421[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6422[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6423[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6424[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6425[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6426[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6427[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6428[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6429[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6430[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6431[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6432[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6433[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6434[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6435[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6436[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6437[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6438[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6439[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6440[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6441[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6442[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6443[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6444[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6445[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6446[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6447[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6448[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6449[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6450[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6451[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6452[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6453[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6454[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6455[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6456[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6457[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6458[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6459[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6460[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6461[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6462[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6463[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6464[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6465[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6466[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6467[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6468[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6469[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6470[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6471[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6472[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6473[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6474[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6475[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6476[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6477[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6478[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6479[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6480[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6481[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6482[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6483[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6484[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6485[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6486[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6487[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6488[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6489[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6490[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6491[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6492[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6493[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6494[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6495[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6496[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6497[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6498[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6499[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6500[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6501[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6502[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6503[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6504[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6505[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6506[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6507[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6508[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6509[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6510[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6511[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6512[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6513[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6514[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6515[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6516[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6517[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6518[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6519[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6520[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6521[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6522[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6523[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6524[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6525[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6526[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6527[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6528[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6529[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6530[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6531[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6532[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6533[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6534[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6535[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6536[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6537[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6538[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6539[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6540[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6541[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6542[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6543[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6544[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6545[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6546[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6547[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6548[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6549[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6550[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6551[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6552[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6553[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6554[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6555[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6556[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6557[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6558[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6559[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6560[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6561[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6562[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6563[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6564[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6565[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6566[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6567[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6568[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6569[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6570[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6571[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6572[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6573[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6574[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6575[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6576[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6577[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6578[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6579[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6580[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6581[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6582[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6583[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6584[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6585[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6586[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6587[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6588[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6589[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6590[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6591[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6592[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6593[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6594[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6595[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6596[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6597[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6598[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6599[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6600[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6601[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6602[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6603[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6604[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6605[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6606[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6607[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6608[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6609[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6610[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6611[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6612[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6613[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6614[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6615[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6616[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6617[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6618[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6619[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6620[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6621[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6622[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6623[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6624[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6625[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6626[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6627[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6628[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6629[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6630[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6631[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6632[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6633[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6634[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6635[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6636[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6637[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6638[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6639[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6640[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6641[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6642[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6643[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6644[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6645[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6646[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6647[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6648[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6649[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6650[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6651[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6652[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6653[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6654[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6655[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6656[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6657[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6658[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6659[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6660[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6661[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6662[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6663[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6664[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6665[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6666[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6667[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6668[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6669[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6670[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6671[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6672[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6673[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6674[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6675[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6676[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6677[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6678[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6679[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6680[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6681[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6682[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6683[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6684[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6685[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6686[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6687[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6688[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6689[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6690[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6691[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6692[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6693[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6694[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6695[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6696[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6697[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6698[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6699[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6700[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6701[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6702[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6703[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6704[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6705[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6706[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6707[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6708[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6709[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6710[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6711[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6712[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6713[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6714[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6715[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6716[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6717[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6718[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6719[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6720[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6721[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6722[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6723[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6724[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6725[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6726[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6727[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6728[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6729[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6730[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6731[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6732[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6733[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6734[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6735[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6736[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6737[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6738[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6739[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6740[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6741[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6742[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6743[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6744[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6745[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6746[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6747[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6748[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6749[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6750[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6751[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6752[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6753[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6754[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6755[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6756[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6757[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6758[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6759[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6760[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6761[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6762[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6763[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6764[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6765[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6766[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6767[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6768[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6769[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6770[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6771[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6772[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6773[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6774[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6775[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6776[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6777[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6778[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6779[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6780[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6781[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6782[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6783[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6784[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6785[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6786[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6787[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6788[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6789[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6790[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6791[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6792[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6793[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6794[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6795[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6796[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6797[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6798[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6799[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6800[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6801[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6802[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6803[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6804[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6805[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6806[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6807[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6808[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6809[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6810[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6811[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6812[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6813[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6814[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6815[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6816[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6817[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6818[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6819[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6820[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6821[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6822[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6823[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6824[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6825[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6826[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6827[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6828[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6829[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6830[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6831[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6832[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6833[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6834[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6835[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6836[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6837[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6838[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6839[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6840[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6841[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6842[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6843[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6844[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6845[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6846[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6847[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6848[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6849[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6850[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6851[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6852[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6853[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6854[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6855[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6856[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6857[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6858[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6859[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6860[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6861[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6862[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6863[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6864[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6865[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6866[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6867[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6868[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6869[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6870[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6871[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6872[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6873[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6874[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6875[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6876[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6877[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6878[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6879[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6880[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6881[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6882[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6883[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6884[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6885[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6886[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6887[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6888[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6889[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6890[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6891[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6892[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6893[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6894[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6895[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6896[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6897[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6898[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6899[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6900[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6901[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6902[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6903[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6904[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6905[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6906[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6907[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6908[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6909[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6910[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6911[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6912[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6913[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6914[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6915[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6916[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6917[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6918[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6919[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6920[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6921[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6922[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6923[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6924[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6925[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6926[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6927[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6928[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6929[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6930[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6931[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6932[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6933[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6934[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6935[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6936[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6937[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6938[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6939[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6940[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6941[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6942[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6943[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6944[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6945[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6946[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6947[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6948[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6949[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6950[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6951[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6952[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6953[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6954[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6955[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6956[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6957[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6958[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6959[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6960[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6961[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6962[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6963[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6964[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6965[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6966[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6967[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6968[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6969[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6970[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6971[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6972[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6973[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6974[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6975[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6976[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6977[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6978[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6979[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6980[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6981[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6982[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6983[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6984[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6985[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6986[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6987[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6988[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6989[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6990[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6991[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6992[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6993[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6994[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6995[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6996[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6997[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6998[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType6999[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7000[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7001[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7002[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7003[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7004[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7005[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7006[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7007[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7008[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7009[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7010[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7011[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7012[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7013[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7014[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7015[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7016[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7017[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7018[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7019[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7020[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7021[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7022[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7023[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7024[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7025[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7026[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7027[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7028[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7029[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7030[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7031[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7032[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7033[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7034[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7035[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7036[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7037[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7038[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7039[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7040[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7041[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7042[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7043[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7044[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7045[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7046[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7047[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7048[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7049[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7050[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7051[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7052[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7053[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7054[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7055[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7056[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7057[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7058[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7059[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7060[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7061[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7062[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7063[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7064[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7065[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7066[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7067[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7068[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7069[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7070[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7071[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7072[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7073[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7074[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7075[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7076[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7077[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7078[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7079[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7080[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7081[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7082[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7083[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7084[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7085[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7086[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7087[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7088[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7089[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7090[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7091[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7092[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7093[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7094[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7095[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7096[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7097[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7098[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7099[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7100[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7101[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7102[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7103[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7104[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7105[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7106[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7107[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7108[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7109[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7110[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7111[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7112[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7113[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7114[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7115[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7116[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7117[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7118[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7119[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7120[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7121[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7122[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7123[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7124[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7125[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7126[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7127[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7128[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7129[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7130[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7131[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7132[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7133[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7134[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7135[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7136[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7137[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7138[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7139[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7140[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7141[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7142[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7143[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7144[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7145[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7146[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7147[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7148[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7149[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7150[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7151[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7152[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7153[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7154[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7155[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7156[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7157[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7158[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7159[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7160[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7161[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7162[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7163[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7164[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7165[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7166[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7167[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7168[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7169[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7170[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7171[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7172[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7173[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7174[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7175[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7176[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7177[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7178[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7179[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7180[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7181[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7182[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7183[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7184[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7185[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7186[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7187[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7188[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7189[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7190[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7191[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7192[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7193[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7194[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7195[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7196[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7197[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7198[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7199[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7200[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7201[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7202[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7203[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7204[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7205[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7206[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7207[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7208[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7209[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7210[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7211[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7212[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7213[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7214[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7215[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7216[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7217[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7218[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7219[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7220[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7221[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7222[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7223[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7224[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7225[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7226[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7227[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7228[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7229[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7230[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7231[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7232[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7233[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7234[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7235[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7236[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7237[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7238[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7239[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7240[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7241[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7242[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7243[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7244[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7245[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7246[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7247[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7248[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7249[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7250[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7251[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7252[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7253[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7254[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7255[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7256[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7257[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7258[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7259[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7260[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7261[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7262[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7263[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7264[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7265[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7266[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7267[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7268[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7269[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7270[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7271[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7272[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7273[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7274[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7275[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7276[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7277[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7278[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7279[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7280[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7281[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7282[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7283[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7284[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7285[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7286[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7287[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7288[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7289[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7290[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7291[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7292[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7293[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7294[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7295[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7296[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7297[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7298[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7299[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7300[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7301[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7302[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7303[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7304[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7305[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7306[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7307[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7308[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7309[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7310[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7311[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7312[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7313[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7314[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7315[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7316[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7317[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7318[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7319[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7320[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7321[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7322[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7323[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7324[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7325[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7326[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7327[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7328[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7329[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7330[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7331[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7332[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7333[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7334[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7335[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7336[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7337[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7338[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7339[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7340[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7341[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7342[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7343[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7344[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7345[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7346[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7347[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7348[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7349[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7350[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7351[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7352[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7353[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7354[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7355[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7356[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7357[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7358[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7359[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7360[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7361[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7362[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7363[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7364[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7365[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7366[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7367[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7368[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7369[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7370[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7371[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7372[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7373[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7374[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7375[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7376[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7377[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7378[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7379[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7380[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7381[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7382[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7383[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7384[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7385[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7386[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7387[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7388[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7389[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7390[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7391[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7392[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7393[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7394[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7395[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7396[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7397[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7398[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7399[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7400[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7401[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7402[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7403[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7404[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7405[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7406[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7407[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7408[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7409[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7410[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7411[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7412[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7413[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7414[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7415[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7416[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7417[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7418[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7419[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7420[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7421[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7422[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7423[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7424[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7425[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7426[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7427[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7428[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7429[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7430[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7431[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7432[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7433[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7434[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7435[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7436[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7437[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7438[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7439[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7440[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7441[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7442[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7443[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7444[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7445[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7446[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7447[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7448[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7449[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7450[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7451[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7452[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7453[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7454[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7455[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7456[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7457[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7458[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7459[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7460[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7461[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7462[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7463[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7464[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7465[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7466[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7467[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7468[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7469[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7470[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7471[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7472[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7473[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7474[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7475[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7476[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7477[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7478[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7479[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7480[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7481[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7482[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7483[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7484[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7485[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7486[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7487[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7488[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7489[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7490[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7491[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7492[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7493[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7494[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7495[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7496[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7497[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7498[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7499[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7500[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7501[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7502[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7503[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7504[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7505[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7506[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7507[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7508[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7509[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7510[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7511[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7512[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7513[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7514[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7515[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7516[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7517[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7518[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7519[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7520[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7521[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7522[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7523[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7524[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7525[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7526[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7527[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7528[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7529[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7530[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7531[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7532[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7533[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7534[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7535[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7536[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7537[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7538[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7539[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7540[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7541[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7542[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7543[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7544[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7545[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7546[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7547[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7548[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7549[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7550[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7551[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7552[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7553[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7554[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7555[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7556[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7557[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7558[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7559[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7560[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7561[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7562[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7563[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7564[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7565[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7566[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7567[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7568[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7569[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7570[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7571[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7572[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7573[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7574[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7575[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7576[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7577[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7578[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7579[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7580[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7581[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7582[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7583[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7584[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7585[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7586[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7587[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7588[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7589[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7590[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7591[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7592[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7593[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7594[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7595[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7596[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7597[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7598[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7599[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7600[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7601[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7602[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7603[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7604[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7605[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7606[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7607[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7608[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7609[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7610[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7611[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7612[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7613[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7614[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7615[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7616[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7617[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7618[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7619[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7620[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7621[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7622[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7623[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7624[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7625[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7626[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7627[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7628[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7629[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7630[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7631[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7632[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7633[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7634[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7635[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7636[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7637[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7638[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7639[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7640[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7641[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7642[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7643[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7644[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7645[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7646[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7647[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7648[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7649[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7650[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7651[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7652[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7653[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7654[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7655[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7656[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7657[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7658[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7659[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7660[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7661[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7662[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7663[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7664[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7665[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7666[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7667[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7668[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7669[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7670[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7671[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7672[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7673[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7674[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7675[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7676[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7677[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7678[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7679[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7680[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7681[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7682[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7683[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7684[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7685[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7686[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7687[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7688[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7689[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7690[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7691[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7692[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7693[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7694[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7695[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7696[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7697[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7698[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7699[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7700[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7701[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7702[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7703[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7704[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7705[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7706[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7707[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7708[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7709[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7710[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7711[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7712[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7713[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7714[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7715[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7716[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7717[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7718[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7719[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7720[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7721[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7722[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7723[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7724[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7725[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7726[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7727[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7728[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7729[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7730[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7731[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7732[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7733[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7734[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7735[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7736[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7737[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7738[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7739[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7740[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7741[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7742[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7743[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7744[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7745[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7746[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7747[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7748[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7749[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7750[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7751[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7752[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7753[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7754[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7755[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7756[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7757[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7758[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7759[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7760[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7761[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7762[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7763[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7764[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7765[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7766[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7767[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7768[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7769[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7770[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7771[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7772[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7773[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7774[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7775[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7776[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7777[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7778[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7779[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7780[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7781[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7782[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7783[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7784[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7785[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7786[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7787[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7788[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7789[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7790[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7791[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7792[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7793[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7794[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7795[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7796[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7797[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7798[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7799[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7800[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7801[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7802[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7803[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7804[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7805[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7806[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7807[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7808[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7809[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7810[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7811[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7812[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7813[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7814[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7815[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7816[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7817[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7818[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7819[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7820[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7821[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7822[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7823[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7824[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7825[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7826[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7827[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7828[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7829[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7830[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7831[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7832[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7833[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7834[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7835[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7836[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7837[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7838[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7839[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7840[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7841[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7842[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7843[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7844[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7845[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7846[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7847[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7848[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7849[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7850[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7851[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7852[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7853[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7854[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7855[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7856[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7857[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7858[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7859[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7860[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7861[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7862[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7863[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7864[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7865[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7866[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7867[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7868[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7869[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7870[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7871[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7872[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7873[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7874[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7875[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7876[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7877[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7878[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7879[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7880[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7881[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7882[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7883[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7884[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7885[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7886[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7887[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7888[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7889[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7890[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7891[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7892[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7893[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7894[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7895[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7896[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7897[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7898[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7899[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7900[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7901[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7902[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7903[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7904[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7905[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7906[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7907[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7908[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7909[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7910[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7911[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7912[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7913[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7914[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7915[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7916[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7917[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7918[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7919[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7920[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7921[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7922[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7923[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7924[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7925[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7926[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7927[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7928[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7929[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7930[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7931[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7932[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7933[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7934[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7935[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7936[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7937[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7938[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7939[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7940[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7941[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7942[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7943[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7944[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7945[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7946[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7947[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7948[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7949[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7950[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7951[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7952[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7953[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7954[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7955[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7956[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7957[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7958[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7959[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7960[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7961[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7962[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7963[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7964[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7965[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7966[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7967[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7968[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7969[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7970[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7971[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7972[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7973[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7974[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7975[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7976[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7977[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7978[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7979[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7980[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7981[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7982[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7983[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7984[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7985[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7986[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7987[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7988[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7989[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7990[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7991[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7992[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7993[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7994[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7995[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7996[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7997[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7998[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType7999[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8000[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8001[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8002[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8003[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8004[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8005[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8006[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8007[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8008[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8009[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8010[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8011[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8012[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8013[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8014[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8015[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8016[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8017[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8018[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8019[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8020[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8021[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8022[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8023[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8024[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8025[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8026[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8027[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8028[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8029[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8030[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8031[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8032[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8033[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8034[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8035[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8036[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8037[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8038[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8039[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8040[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8041[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8042[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8043[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8044[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8045[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8046[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8047[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8048[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8049[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8050[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8051[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8052[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8053[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8054[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8055[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8056[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8057[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8058[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8059[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8060[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8061[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8062[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8063[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8064[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8065[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8066[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8067[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8068[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8069[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8070[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8071[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8072[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8073[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8074[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8075[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8076[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8077[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8078[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8079[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8080[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8081[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8082[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8083[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8084[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8085[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8086[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8087[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8088[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8089[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8090[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8091[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8092[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8093[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8094[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8095[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8096[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8097[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8098[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8099[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8100[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8101[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8102[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8103[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8104[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8105[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8106[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8107[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8108[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8109[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8110[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8111[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8112[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8113[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8114[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8115[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8116[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8117[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8118[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8119[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8120[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8121[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8122[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8123[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8124[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8125[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8126[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8127[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8128[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8129[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8130[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8131[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8132[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8133[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8134[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8135[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8136[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8137[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8138[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8139[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8140[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8141[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8142[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8143[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8144[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8145[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8146[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8147[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8148[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8149[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8150[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8151[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8152[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8153[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8154[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8155[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8156[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8157[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8158[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8159[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8160[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8161[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8162[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8163[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8164[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8165[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8166[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8167[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8168[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8169[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8170[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8171[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8172[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8173[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8174[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8175[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8176[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8177[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8178[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8179[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8180[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8181[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8182[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8183[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8184[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8185[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8186[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8187[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8188[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8189[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8190[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8191[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8192[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8193[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8194[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8195[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8196[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8197[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8198[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8199[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8200[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8201[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8202[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8203[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8204[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8205[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8206[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8207[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8208[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8209[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8210[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8211[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8212[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8213[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8214[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8215[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8216[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8217[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8218[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8219[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8220[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8221[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8222[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8223[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8224[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8225[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8226[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8227[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8228[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8229[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8230[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8231[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8232[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8233[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8234[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8235[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8236[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8237[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8238[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8239[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8240[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8241[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8242[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8243[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8244[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8245[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8246[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8247[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8248[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8249[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8250[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8251[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8252[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8253[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8254[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8255[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8256[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8257[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8258[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8259[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8260[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8261[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8262[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8263[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8264[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8265[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8266[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8267[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8268[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8269[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8270[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8271[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8272[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8273[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8274[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8275[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8276[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8277[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8278[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8279[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8280[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8281[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8282[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8283[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8284[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8285[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8286[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8287[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8288[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8289[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8290[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8291[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8292[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8293[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8294[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8295[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8296[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8297[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8298[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8299[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8300[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8301[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8302[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8303[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8304[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8305[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8306[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8307[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8308[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8309[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8310[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8311[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8312[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8313[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8314[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8315[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8316[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8317[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8318[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8319[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8320[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8321[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8322[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8323[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8324[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8325[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8326[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8327[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8328[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8329[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8330[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8331[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8332[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8333[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8334[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8335[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8336[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8337[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8338[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8339[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8340[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8341[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8342[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8343[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8344[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8345[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8346[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8347[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8348[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8349[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8350[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8351[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8352[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8353[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8354[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8355[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8356[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8357[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8358[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8359[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8360[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8361[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8362[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8363[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8364[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8365[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8366[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8367[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8368[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8369[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8370[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8371[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8372[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8373[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8374[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8375[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8376[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8377[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8378[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8379[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8380[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8381[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8382[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8383[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8384[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8385[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8386[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8387[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8388[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8389[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8390[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8391[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8392[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8393[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8394[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8395[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8396[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8397[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8398[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8399[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8400[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8401[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8402[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8403[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8404[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8405[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8406[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8407[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8408[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8409[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8410[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8411[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8412[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8413[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8414[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8415[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8416[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8417[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8418[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8419[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8420[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8421[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8422[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8423[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8424[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8425[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8426[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8427[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8428[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8429[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8430[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8431[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8432[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8433[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8434[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8435[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8436[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8437[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8438[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8439[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8440[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8441[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8442[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8443[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8444[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8445[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8446[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8447[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8448[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8449[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8450[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8451[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8452[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8453[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8454[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8455[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8456[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8457[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8458[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8459[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8460[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8461[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8462[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8463[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8464[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8465[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8466[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8467[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8468[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8469[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8470[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8471[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8472[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8473[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8474[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8475[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8476[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8477[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8478[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8479[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8480[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8481[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8482[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8483[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8484[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8485[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8486[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8487[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8488[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8489[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8490[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8491[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8492[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8493[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8494[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8495[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8496[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8497[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8498[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8499[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8500[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8501[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8502[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8503[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8504[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8505[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8506[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8507[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8508[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8509[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8510[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8511[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8512[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8513[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8514[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8515[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8516[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8517[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8518[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8519[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8520[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8521[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8522[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8523[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8524[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8525[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8526[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8527[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8528[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8529[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8530[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8531[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8532[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8533[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8534[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8535[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8536[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8537[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8538[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8539[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8540[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8541[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8542[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8543[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8544[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8545[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8546[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8547[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8548[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8549[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8550[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8551[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8552[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8553[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8554[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8555[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8556[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8557[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8558[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8559[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8560[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8561[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8562[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8563[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8564[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8565[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8566[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8567[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8568[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8569[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8570[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8571[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8572[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8573[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8574[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8575[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8576[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8577[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8578[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8579[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8580[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8581[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8582[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8583[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8584[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8585[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8586[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8587[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8588[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8589[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8590[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8591[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8592[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8593[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8594[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8595[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8596[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8597[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8598[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8599[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8600[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8601[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8602[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8603[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8604[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8605[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8606[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8607[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8608[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8609[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8610[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8611[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8612[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8613[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8614[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8615[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8616[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8617[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8618[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8619[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8620[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8621[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8622[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8623[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8624[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8625[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8626[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8627[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8628[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8629[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8630[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8631[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8632[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8633[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8634[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8635[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8636[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8637[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8638[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8639[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8640[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8641[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8642[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8643[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8644[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8645[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8646[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8647[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8648[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8649[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8650[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8651[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8652[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8653[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8654[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8655[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8656[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8657[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8658[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8659[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8660[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8661[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8662[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8663[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8664[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8665[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8666[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8667[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8668[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8669[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8670[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8671[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8672[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8673[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8674[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8675[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8676[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8677[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8678[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8679[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8680[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8681[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8682[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8683[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8684[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8685[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8686[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8687[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8688[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8689[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8690[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8691[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8692[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8693[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8694[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8695[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8696[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8697[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8698[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8699[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8700[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8701[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8702[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8703[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8704[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8705[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8706[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8707[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8708[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8709[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8710[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8711[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8712[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8713[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8714[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8715[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8716[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8717[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8718[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8719[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8720[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8721[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8722[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8723[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8724[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8725[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8726[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8727[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8728[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8729[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8730[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8731[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8732[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8733[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8734[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8735[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8736[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8737[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8738[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8739[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8740[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8741[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8742[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8743[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8744[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8745[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8746[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8747[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8748[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8749[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8750[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8751[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8752[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8753[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8754[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8755[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8756[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8757[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8758[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8759[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8760[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8761[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8762[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8763[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8764[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8765[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8766[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8767[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8768[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8769[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8770[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8771[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8772[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8773[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8774[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8775[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8776[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8777[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8778[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8779[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8780[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8781[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8782[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8783[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8784[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8785[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8786[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8787[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8788[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8789[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8790[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8791[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8792[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8793[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8794[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8795[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8796[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8797[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8798[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8799[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8800[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8801[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8802[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8803[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8804[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8805[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8806[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8807[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8808[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8809[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8810[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8811[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8812[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8813[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8814[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8815[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8816[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8817[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8818[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8819[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8820[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8821[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8822[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8823[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8824[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8825[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8826[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8827[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8828[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8829[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8830[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8831[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8832[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8833[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8834[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8835[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8836[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8837[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8838[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8839[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8840[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8841[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8842[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8843[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8844[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8845[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8846[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8847[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8848[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8849[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8850[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8851[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8852[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8853[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8854[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8855[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8856[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8857[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8858[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8859[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8860[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8861[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8862[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8863[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8864[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8865[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8866[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8867[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8868[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8869[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8870[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8871[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8872[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8873[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8874[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8875[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8876[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8877[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8878[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8879[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8880[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8881[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8882[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8883[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8884[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8885[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8886[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8887[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8888[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8889[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8890[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8891[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8892[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8893[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8894[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8895[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8896[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8897[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8898[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8899[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8900[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8901[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8902[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8903[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8904[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8905[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8906[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8907[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8908[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8909[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8910[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8911[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8912[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8913[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8914[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8915[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8916[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8917[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8918[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8919[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8920[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8921[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8922[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8923[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8924[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8925[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8926[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8927[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8928[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8929[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8930[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8931[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8932[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8933[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8934[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8935[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8936[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8937[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8938[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8939[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8940[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8941[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8942[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8943[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8944[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8945[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8946[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8947[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8948[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8949[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8950[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8951[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8952[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8953[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8954[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8955[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8956[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8957[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8958[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8959[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8960[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8961[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8962[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8963[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8964[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8965[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8966[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8967[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8968[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8969[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8970[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8971[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8972[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8973[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8974[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8975[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8976[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8977[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8978[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8979[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8980[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8981[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8982[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8983[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8984[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8985[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8986[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8987[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8988[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8989[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8990[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8991[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8992[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8993[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8994[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8995[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8996[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8997[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8998[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType8999[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9000[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9001[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9002[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9003[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9004[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9005[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9006[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9007[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9008[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9009[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9010[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9011[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9012[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9013[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9014[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9015[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9016[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9017[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9018[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9019[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9020[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9021[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9022[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9023[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9024[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9025[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9026[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9027[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9028[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9029[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9030[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9031[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9032[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9033[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9034[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9035[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9036[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9037[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9038[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9039[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9040[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9041[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9042[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9043[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9044[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9045[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9046[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9047[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9048[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9049[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9050[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9051[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9052[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9053[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9054[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9055[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9056[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9057[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9058[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9059[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9060[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9061[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9062[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9063[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9064[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9065[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9066[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9067[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9068[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9069[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9070[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9071[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9072[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9073[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9074[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9075[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9076[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9077[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9078[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9079[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9080[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9081[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9082[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9083[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9084[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9085[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9086[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9087[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9088[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9089[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9090[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9091[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9092[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9093[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9094[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9095[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9096[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9097[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9098[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9099[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9100[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9101[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9102[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9103[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9104[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9105[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9106[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9107[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9108[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9109[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9110[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9111[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9112[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9113[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9114[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9115[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9116[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9117[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9118[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9119[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9120[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9121[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9122[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9123[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9124[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9125[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9126[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9127[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9128[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9129[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9130[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9131[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9132[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9133[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9134[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9135[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9136[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9137[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9138[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9139[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9140[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9141[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9142[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9143[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9144[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9145[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9146[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9147[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9148[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9149[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9150[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9151[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9152[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9153[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9154[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9155[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9156[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9157[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9158[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9159[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9160[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9161[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9162[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9163[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9164[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9165[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9166[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9167[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9168[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9169[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9170[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9171[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9172[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9173[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9174[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9175[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9176[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9177[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9178[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9179[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9180[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9181[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9182[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9183[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9184[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9185[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9186[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9187[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9188[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9189[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9190[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9191[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9192[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9193[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9194[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9195[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9196[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9197[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9198[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9199[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9200[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9201[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9202[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9203[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9204[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9205[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9206[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9207[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9208[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9209[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9210[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9211[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9212[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9213[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9214[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9215[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9216[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9217[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9218[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9219[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9220[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9221[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9222[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9223[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9224[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9225[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9226[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9227[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9228[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9229[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9230[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9231[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9232[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9233[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9234[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9235[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9236[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9237[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9238[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9239[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9240[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9241[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9242[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9243[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9244[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9245[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9246[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9247[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9248[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9249[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9250[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9251[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9252[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9253[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9254[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9255[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9256[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9257[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9258[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9259[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9260[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9261[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9262[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9263[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9264[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9265[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9266[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9267[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9268[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9269[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9270[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9271[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9272[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9273[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9274[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9275[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9276[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9277[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9278[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9279[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9280[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9281[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9282[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9283[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9284[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9285[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9286[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9287[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9288[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9289[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9290[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9291[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9292[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9293[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9294[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9295[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9296[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9297[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9298[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9299[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9300[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9301[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9302[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9303[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9304[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9305[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9306[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9307[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9308[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9309[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9310[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9311[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9312[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9313[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9314[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9315[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9316[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9317[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9318[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9319[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9320[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9321[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9322[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9323[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9324[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9325[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9326[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9327[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9328[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9329[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9330[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9331[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9332[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9333[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9334[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9335[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9336[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9337[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9338[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9339[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9340[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9341[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9342[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9343[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9344[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9345[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9346[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9347[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9348[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9349[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9350[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9351[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9352[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9353[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9354[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9355[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9356[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9357[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9358[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9359[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9360[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9361[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9362[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9363[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9364[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9365[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9366[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9367[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9368[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9369[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9370[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9371[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9372[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9373[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9374[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9375[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9376[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9377[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9378[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9379[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9380[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9381[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9382[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9383[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9384[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9385[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9386[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9387[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9388[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9389[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9390[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9391[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9392[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9393[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9394[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9395[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9396[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9397[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9398[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9399[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9400[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9401[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9402[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9403[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9404[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9405[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9406[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9407[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9408[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9409[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9410[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9411[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9412[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9413[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9414[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9415[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9416[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9417[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9418[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9419[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9420[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9421[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9422[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9423[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9424[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9425[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9426[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9427[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9428[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9429[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9430[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9431[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9432[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9433[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9434[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9435[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9436[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9437[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9438[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9439[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9440[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9441[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9442[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9443[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9444[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9445[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9446[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9447[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9448[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9449[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9450[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9451[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9452[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9453[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9454[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9455[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9456[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9457[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9458[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9459[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9460[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9461[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9462[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9463[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9464[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9465[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9466[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9467[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9468[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9469[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9470[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9471[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9472[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9473[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9474[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9475[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9476[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9477[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9478[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9479[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9480[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9481[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9482[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9483[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9484[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9485[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9486[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9487[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9488[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9489[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9490[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9491[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9492[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9493[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9494[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9495[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9496[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9497[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9498[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9499[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9500[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9501[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9502[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9503[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9504[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9505[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9506[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9507[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9508[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9509[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9510[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9511[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9512[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9513[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9514[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9515[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9516[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9517[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9518[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9519[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9520[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9521[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9522[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9523[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9524[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9525[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9526[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9527[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9528[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9529[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9530[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9531[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9532[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9533[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9534[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9535[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9536[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9537[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9538[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9539[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9540[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9541[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9542[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9543[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9544[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9545[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9546[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9547[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9548[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9549[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9550[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9551[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9552[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9553[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9554[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9555[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9556[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9557[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9558[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9559[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9560[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9561[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9562[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9563[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9564[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9565[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9566[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9567[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9568[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9569[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9570[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9571[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9572[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9573[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9574[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9575[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9576[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9577[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9578[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9579[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9580[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9581[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9582[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9583[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9584[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9585[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9586[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9587[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9588[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9589[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9590[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9591[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9592[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9593[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9594[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9595[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9596[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9597[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9598[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9599[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9600[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9601[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9602[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9603[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9604[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9605[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9606[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9607[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9608[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9609[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9610[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9611[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9612[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9613[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9614[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9615[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9616[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9617[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9618[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9619[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9620[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9621[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9622[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9623[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9624[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9625[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9626[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9627[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9628[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9629[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9630[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9631[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9632[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9633[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9634[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9635[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9636[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9637[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9638[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9639[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9640[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9641[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9642[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9643[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9644[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9645[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9646[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9647[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9648[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9649[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9650[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9651[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9652[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9653[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9654[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9655[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9656[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9657[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9658[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9659[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9660[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9661[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9662[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9663[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9664[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9665[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9666[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9667[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9668[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9669[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9670[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9671[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9672[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9673[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9674[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9675[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9676[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9677[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9678[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9679[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9680[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9681[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9682[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9683[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9684[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9685[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9686[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9687[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9688[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9689[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9690[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9691[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9692[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9693[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9694[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9695[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9696[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9697[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9698[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9699[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9700[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9701[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9702[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9703[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9704[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9705[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9706[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9707[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9708[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9709[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9710[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9711[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9712[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9713[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9714[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9715[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9716[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9717[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9718[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9719[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9720[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9721[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9722[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9723[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9724[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9725[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9726[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9727[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9728[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9729[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9730[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9731[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9732[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9733[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9734[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9735[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9736[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9737[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9738[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9739[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9740[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9741[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9742[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9743[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9744[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9745[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9746[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9747[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9748[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9749[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9750[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9751[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9752[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9753[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9754[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9755[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9756[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9757[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9758[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9759[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9760[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9761[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9762[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9763[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9764[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9765[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9766[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9767[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9768[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9769[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9770[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9771[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9772[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9773[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9774[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9775[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9776[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9777[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9778[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9779[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9780[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9781[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9782[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9783[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9784[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9785[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9786[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9787[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9788[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9789[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9790[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9791[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9792[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9793[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9794[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9795[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9796[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9797[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9798[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9799[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9800[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9801[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9802[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9803[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9804[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9805[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9806[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9807[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9808[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9809[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9810[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9811[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9812[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9813[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9814[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9815[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9816[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9817[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9818[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9819[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9820[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9821[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9822[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9823[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9824[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9825[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9826[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9827[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9828[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9829[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9830[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9831[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9832[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9833[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9834[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9835[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9836[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9837[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9838[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9839[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9840[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9841[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9842[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9843[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9844[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9845[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9846[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9847[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9848[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9849[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9850[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9851[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9852[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9853[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9854[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9855[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9856[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9857[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9858[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9859[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9860[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9861[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9862[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9863[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9864[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9865[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9866[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9867[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9868[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9869[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9870[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9871[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9872[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9873[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9874[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9875[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9876[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9877[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9878[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9879[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9880[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9881[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9882[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9883[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9884[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9885[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9886[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9887[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9888[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9889[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9890[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9891[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9892[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9893[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9894[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9895[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9896[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9897[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9898[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9899[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9900[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9901[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9902[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9903[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9904[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9905[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9906[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9907[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9908[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9909[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9910[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9911[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9912[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9913[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9914[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9915[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9916[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9917[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9918[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9919[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9920[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9921[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9922[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9923[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9924[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9925[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9926[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9927[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9928[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9929[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9930[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9931[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9932[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9933[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9934[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9935[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9936[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9937[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9938[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9939[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9940[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9941[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9942[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9943[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9944[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9945[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9946[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9947[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9948[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9949[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9950[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9951[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9952[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9953[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9954[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9955[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9956[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9957[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9958[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9959[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9960[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9961[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9962[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9963[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9964[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9965[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9966[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9967[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9968[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9969[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9970[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9971[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9972[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9973[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9974[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9975[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9976[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9977[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9978[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9979[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9980[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9981[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9982[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9983[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9984[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9985[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9986[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9987[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9988[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9989[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9990[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9991[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9992[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9993[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9994[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9995[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9996[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9997[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9998[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType9999[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType10000[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType10001[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType10002[T number](a, b T) T {
if a > b {
return a
}
return b
}
func MaxOfType10003[T number](a, b T) T {
if a > b {
return a
}
return b
} | generated/generics.go | 0.777596 | 0.715958 | generics.go | starcoder |
package timefn
import "time"
// StartOfSecond returns the start of the second.
func StartOfSecond(t time.Time) time.Time {
return time.Date(t.Year(), t.Month(), t.Day(), t.Hour(), t.Minute(), t.Second(), 0, t.Location())
}
// EndOfSecond returns the end of the second.
func EndOfSecond(t time.Time) time.Time {
return StartOfSecond(t).Add(time.Second).Add(-time.Nanosecond)
}
// StartOfMinute returns the start of the minute.
func StartOfMinute(t time.Time) time.Time {
return time.Date(t.Year(), t.Month(), t.Day(), t.Hour(), t.Minute(), 0, 0, t.Location())
}
// EndOfMinute returns the end of the minute.
func EndOfMinute(t time.Time) time.Time {
return StartOfMinute(t).Add(time.Minute).Add(-time.Nanosecond)
}
// StartOfHour returns the start of the hour.
func StartOfHour(t time.Time) time.Time {
return time.Date(t.Year(), t.Month(), t.Day(), t.Hour(), 0, 0, 0, t.Location())
}
// EndOfHour returns the end of the hour.
func EndOfHour(t time.Time) time.Time {
return StartOfHour(t).Add(time.Hour).Add(-time.Nanosecond)
}
// StartOfDay returns the start of the day.
func StartOfDay(t time.Time) time.Time {
return time.Date(t.Year(), t.Month(), t.Day(), 0, 0, 0, 0, t.Location())
}
// EndOfDay returns the end of the day.
func EndOfDay(t time.Time) time.Time {
return StartOfDay(t).AddDate(0, 0, 1).Add(-time.Nanosecond)
}
// StartOfWeek returns the start (sunday) of the week.
func StartOfWeek(t time.Time) time.Time {
return StartOfDay(t.AddDate(0, 0, -int(t.Weekday())))
}
// EndOfWeek returns the end (saturday) of the week.
func EndOfWeek(t time.Time) time.Time {
return EndOfDay(t.AddDate(0, 0, 6-int(t.Weekday())))
}
// StartOfISOWeek returns the ISO start (monday) of the week.
func StartOfISOWeek(t time.Time) time.Time {
return StartOfDay(t.AddDate(0, 0, -int((t.Weekday()+6)%7)))
}
// EndOfISOWeek returns the ISO end (sunday) of the week.
func EndOfISOWeek(t time.Time) time.Time {
return EndOfDay(t.AddDate(0, 0, 6-int((t.Weekday()+6)%7)))
}
// StartOfMonth returns the start of the month.
func StartOfMonth(t time.Time) time.Time {
return time.Date(t.Year(), t.Month(), 1, 0, 0, 0, 0, t.Location())
}
// EndOfMonth returns the start of the month.
func EndOfMonth(t time.Time) time.Time {
return StartOfMonth(t).AddDate(0, 1, 0).Add(-time.Nanosecond)
}
// StartOfYear returns the start of the year.
func StartOfYear(t time.Time) time.Time {
return time.Date(t.Year(), 1, 1, 0, 0, 0, 0, t.Location())
}
// EndOfYear returns the end of the year.
func EndOfYear(t time.Time) time.Time {
return StartOfYear(t).AddDate(1, 0, 0).Add(-time.Nanosecond)
}
// Between determines if t is between l and r (exclusive).
func Between(t, l, r time.Time) bool {
return t.After(l) && t.Before(r)
}
// BetweenInclusive determines if t is between l and r (inclusive).
func BetweenInclusive(t, l, r time.Time) bool {
return SameOrBefore(t, r) && SameOrAfter(t, l)
}
// SameOrBefore determines if t is the same as or before r.
func SameOrBefore(t, r time.Time) bool {
return t.Equal(r) || t.Before(r)
}
// SameOrAfter determines if t is the same as or after l.
func SameOrAfter(t, l time.Time) bool {
return t.Equal(l) || t.After(l)
}
// AtTime returns t with its time set to h hours, m minutes, s seconds and ns nanoseconds.
func AtTime(t time.Time, h, m, s, ns int) time.Time {
return time.Date(t.Year(), t.Month(), t.Day(), h, m, s, ns, t.Location())
} | timefn.go | 0.874614 | 0.767516 | timefn.go | starcoder |
package riddles
import (
"fmt"
"math"
"strconv"
"strings"
"unicode"
)
// https://www.geeksforgeeks.org/string-data-structure/
// sumAllNumbers
// Given a string containing alphanumeric characters,
// calculate sum of all numbers present in the string.
func sumAllNumbers(str string) int {
if len(str) == 0 {
return 0
}
if unicode.IsDigit(rune(str[0])) {
value, _ := strconv.Atoi(string(str[0]))
return value + sumAllNumbers(str[1:])
}
return sumAllNumbers(str[1:])
}
// maxNumeric
// Given an alphanumeric string,
// extract maximum numeric value from that string.
func maxNumeric(str string) int {
if len(str) == 0 {
return 0
}
if unicode.IsDigit(rune(str[0])) {
value, _ := strconv.Atoi(string(str[0]))
max := math.Max(float64(value), float64(maxNumeric(str[1:])))
return int(max)
}
return maxNumeric(str[1:])
}
// reverseInPlace
// duplicate characters from a string
func duplicatedChars(str string) []string {
dups := make(map[rune]int)
for _, v := range str {
dups[v] = dups[v] + 1
}
var res []string
for k, v := range dups {
if v > 1 {
res = append(res, string(k))
}
}
return res
}
// areAnagrams
// two strings are anagrams of each other
func areAnagrams(str1, str2 string) bool {
if len(str1) != len(str2) {
return false
}
acc := make(map[uint8]int)
for i := 0; i < len(str1); i++ {
acc[str1[i]] = acc[str1[i]] + 1
acc[str2[i]] = acc[str2[i]] + 1
}
for _, v := range acc {
if math.Mod(float64(v), 2) != 0 {
return false
}
}
return true
}
// allPermutations
// find all the permutations of a string
func allPermutations(str string, left int) []string {
if left == len(str)-1 {
return []string{str}
}
var strs []string
for i := left; i < len(str); i++ {
runes := []rune(str)
runes[i], runes[left] = runes[left], runes[i]
newStr := string(runes)
x := allPermutations(newStr, left+1)
strs = append(strs, x...)
}
return strs
}
// reverseRecursion
// given string be reversed using recursion
func reverseRecursion(str string) string {
if len(str) <= 1 {
return str
}
return str[len(str)-1:] + reverseRecursion(str[:len(str)-1])
}
// count the occurrence of a given character in a string
func countCharOccurrences(str string, char uint8) int {
if len(str) == 0 {
return 0
}
if str[0] == char {
return 1 + countCharOccurrences(str[1:], char)
}
return countCharOccurrences(str[1:], char)
}
// firstNonRepeatable
// first non-repeated character from a string
func firstNonRepeatable(str string) int32 {
m := make(map[int32]int)
for _, v := range str {
m[v] = m[v] + 1
}
for _, v := range str {
if m[v] == 1 {
return v
}
}
return 0
}
// reverseWords
// reverse words in a given sentence
func reverseWords(str string) string {
split := strings.Split(str, " ")
for i := 0; i < len(split)/2; i++ {
split[i], split[len(split)-1-i] = split[len(split)-1-i], split[i]
}
return strings.Join(split, " ")
}
// areRotation
// check if two strings are a rotation of each other
func areRotation(strA, strB string) bool {
if len(strA) != len(strB) {
return false
}
rB := []rune(strB)
for i := 0; i < len(strA); i++ {
if strA == string(rB) {
return true
}
rB = append(rB[len(strA)-1:], rB[:len(strA)-1]...)
}
return false
}
// isPalindrome
// check if a given string is a palindrome
func isPalindrome(str string) bool {
if len(str) <= 1 {
return true
}
if str[0] == str[len(str)-1] {
return isPalindrome(str[1 : len(str)-1])
}
return false
}
// longestPalindrome
// find the longest palindromic substring in str
func longestPalindrome(str string) string {
if isPalindrome(str) {
return str
}
maxLength := 1
start := 0
for i := 0; i < len(str); i++ {
for j := i; j < len(str); j++ {
flag := 1
// Check palindrome
for k := 0; k < (j-i+1)/2; k++ {
if str[i+k] != str[j-k] {
flag = 0
}
}
// Palindrome
if flag > 0 && (j-i+1) > maxLength {
start = i
maxLength = j - i + 1
}
}
}
fmt.Println(str, start, start+maxLength-1)
return str[start : start+maxLength]
}
// findLongestSubstring
// find the length of the longest substring without repeating characters
func findLongestSubstring(str string) string {
maxStrs := []string{""}
var i int
for _, c := range str {
if strings.ContainsRune(maxStrs[i], c) {
i++
maxStrs = append(maxStrs, "")
}
maxStrs[i] += string(c)
}
for j := 0; j < len(maxStrs)-1; j++ {
if len(maxStrs[j]) > len(maxStrs[j+1]) {
maxStrs[j], maxStrs[j+1] = maxStrs[j+1], maxStrs[j]
}
}
return maxStrs[len(maxStrs)-1]
}
// removeDuplicate
// remove the duplicate character from String
func removeDuplicate(str string) string {
if len(str) <= 0 {
return str
}
if strings.Contains(str[1:], string(str[0])) {
return removeDuplicate(str[1:])
}
return string(str[0]) + removeDuplicate(str[1:])
}
// findMaxWordOccurring
// Given an array of strings, find the most frequent word in a given array
func findMaxWordOccurring(text []string) string {
counter := make(map[string]int)
for _, str := range text {
for _, word := range strings.Split(str, " ") {
counter[word] += 1
}
}
var word string
var count int
for k, v := range counter {
if v > count {
count = v
word = k
}
}
return word
} | riddles/strings.go | 0.742422 | 0.404684 | strings.go | starcoder |
package tree
/**
** Approach: Use the feature of heap
** - Make a heap with all items in the array. According to heap's feature, the root item is the biggest.
** - Swap the root with the last item i in the heap. Then consider item i as being removed from the heap.
** - Make the rest of i - 1 items to be a heap again. Either recursively call MakeHeap (slower),
** or push down the new root with a loop (faster).
** Complexity: O(n*log n)
** - MakeHeap: O(n*log n) + Push down root: O(n*log n)
**/
// HeapSort sort the array with heap
func HeapSort(data []int) []int {
// Make a heap
data = MakeHeap(data)
for i := len(data) - 1; i >= 0; i-- {
// Item i is the smallest. Swap it with the root which is the biggest item.
data[0], data[i] = data[i], data[0]
// Make the rest of i - 1 items to be a heap again by pushing down the new root
index := 0
for true {
child1 := 2*index + 1
child2 := 2*index + 2
// If child index is bigger than the count, there is no more child.
if child1 >= i {
child1 = index
}
if child2 >= i {
child2 = index
}
// If item index is bigger than both children, it is already a heap.
if data[index] >= data[child1] && data[index] >= data[child2] {
break
}
// Otherwise, swap the item index with the bigger child. Then repeat to push it further down.
if data[child1] > data[child2] {
data[child1], data[index] = data[index], data[child1]
index = child1
} else {
data[child2], data[index] = data[index], data[child2]
index = child2
}
}
}
return data
}
// MakeHeap create a heap with array. Complexity: O(n*log n)
func MakeHeap(data []int) []int {
// Add each item to the heap one at a time.
for i := 0; i < len(data); i++ { // O(n)
index := i
for i > 0 { // O(log n) since the complete binary tree is O(log n) level tall.
// For item i, find its parent
parent := (index - 1) / 2
// If item i <= parent, it meets the heap condition so break.
if data[index] <= data[parent] {
break
}
// Otherwise, swap the item i and parent, and repeat the steps for new parent value.
data[index], data[parent] = data[parent], data[index]
index = parent
}
}
return data
} | basic/tree/Heap.go | 0.752104 | 0.656486 | Heap.go | starcoder |
package bit
import (
"math/big"
)
// A bit array.
type Array struct {
*big.Int
}
// NewArray allocates and returns a new Bits set to x.
func NewArray(x int64) *Array {
return &Array{big.NewInt(x)}
}
// Count counts the number of set bits in b.
func (b *Array) Count() (c int) {
for _, v := range b.Bits() {
c += nSetBits(uintptr(v))
}
return
}
// Len returns the length of b in bits. The bit length of 0 is 0.
func (b *Array) Len() int {
return b.Int.BitLen()
}
// Set sets b to x and returns b.
func (b *Array) Set(x *Array) *Array {
b.Int.Set(x.Int)
return b
}
// SetBit sets b to x with x's i'th bit set to a (0 or 1).
func (b *Array) SetBit(x *Array, i int, a uint) *Array {
b.Int.SetBit(x.Int, i, a)
return b
}
// SetString sets b to the value of s, interpreted in the given base, and
// returns b and a boolean indicating success. If SetString fails, the value
// of b is undefined but he returned value is nil.
func (b *Array) SetString(s string, base int) (*Array, bool) {
_, succ := b.Int.SetString(s, base)
return b, succ
}
// Not sets b = ^x and returns b.
func (b *Array) Not(x *Array) *Array {
b.Int.Not(x.Int)
return b
}
// Or sets b = x | y and returns b.
func (b *Array) Or(x, y *Array) *Array {
b.Int.Or(x.Int, y.Int)
return b
}
// And sets b = x & y and returns b.
func (b *Array) And(x, y *Array) *Array {
b.Int.And(x.Int, y.Int)
return b
}
// AndNot sets b = x & ^y and returns b.
func (b *Array) AndNot(x, y *Array) *Array {
b.Int.AndNot(x.Int, y.Int)
return b
}
// AndNot sets b = x ^ y and returns b.
func (b *Array) Xor(x, y *Array) *Array {
b.Int.Xor(x.Int, y.Int)
return b
}
// Count set bits using the Wegner algorithm.
// Adapted from Wegner, CACM 3 (1960), p. 322.
func nSetBits(x uintptr) (n int) {
// n accumulates the total bits set in x, counting only set bits
for ; x > 0; n++ {
// clear the least significant bit set
x &= x - 1
}
return
}
func countBits(a *Array) int {
return a.Count()
}
func countBools(a []bool) (c int) {
for _, v := range a {
if v {
c++
}
}
return
}
func xorBitsInPlace(a, b *Array) *Array {
return a.Xor(a, b)
}
func xorBits(a, b *Array) (c *Array) {
c = NewArray(0)
c.Xor(a, b)
return
}
func xorBoolsInPlace(a, b []bool) []bool {
for i, v := range a {
if (v || b[i]) && !(v && b[i]) {
a[i] = true
}
}
return a
}
func xorBools(a, b []bool) (d []bool) {
d = make([]bool, len(a))
for i, v := range a {
if (v || b[i]) && !(v && b[i]) {
d[i] = true
}
}
return
} | bit/bit.go | 0.762866 | 0.479565 | bit.go | starcoder |
package forGraphBLASGo
import (
"github.com/intel/forGoParallel/parallel"
"github.com/intel/forGoParallel/pipeline"
"github.com/intel/forGoParallel/psort"
"sort"
"sync"
)
type vectorAssign[D any] struct {
u *vectorReference[D]
indices []int
index func(j int) (i int, ok bool)
}
func vectorIndexLookup(indices []int) func(int) (int, bool) {
if nindices, allIndices := isAll(indices); allIndices {
return func(i int) (int, bool) {
return i, i < nindices
}
}
return newIntSearcher(indices).search
}
func newVectorAssign[D any](u *vectorReference[D], indices []int) computeVectorT[D] {
return vectorAssign[D]{
u: u,
indices: indices,
index: vectorIndexLookup(indices)}
}
func resizeAssignIndices(newSize int, indices []int) []int {
n, all := isAll(indices)
if newSize < n {
if all {
return All(newSize)
}
newIndices := make([]int, n)
parallel.Range(0, n, func(low, high int) {
for i := low; i < high; i++ {
if index := indices[i]; index < newSize {
newIndices[i] = index
} else {
newIndices[i] = -1
}
}
})
return newIndices
}
return indices
}
func (compute vectorAssign[D]) resize(newSize int) computeVectorT[D] {
return newVectorAssign[D](compute.u, resizeAssignIndices(newSize, compute.indices))
}
func (compute vectorAssign[D]) assignIndex(index int) (int, bool) {
return compute.index(index)
}
func (compute vectorAssign[D]) computeElement(index int) (result D, ok bool) {
return compute.u.extractElement(index)
}
func (compute vectorAssign[D]) computePipeline() *pipeline.Pipeline[any] {
p := compute.u.getPipeline()
if p == nil {
return nil
}
if n, all := isAll(compute.indices); all {
p.Add(
pipeline.Par(pipeline.Receive(func(_ int, data any) any {
slice := data.(vectorSlice[D])
slice.filter(func(index int, value D) (newIndex int, newValue D, ok bool) {
return index, value, index < n
})
return slice
})),
)
return p
}
p.Add(
pipeline.Par(pipeline.Receive(func(_ int, data any) any {
slice := data.(vectorSlice[D])
slice.filter(func(index int, value D) (newIndex int, newValue D, ok bool) {
if index < len(compute.indices) {
newIndex = compute.indices[index]
newValue = value
ok = newIndex >= 0
}
return
})
return slice
})),
)
if psort.IntsAreSorted(compute.indices) {
return p
}
var result vectorSlice[D]
var wg sync.WaitGroup
wg.Add(1)
var np pipeline.Pipeline[any]
np.Source(vectorSourceWithWaitGroup(&wg, &result.indices, &result.values))
np.Notify(func() {
defer wg.Done()
result.collect(p)
vectorSort(result.indices, result.values)
})
return &np
}
func computeIndexValid(indices []int) func(int) bool {
if nindices, ok := isAll(indices); ok {
return func(index int) bool {
return index < nindices
}
}
psort.StableSort(psort.IntSlice(indices))
return func(index int) bool {
s := sort.SearchInts(indices, index)
return s < len(indices) && indices[s] == index
}
}
type vectorAssignConstant[D any] struct {
value D
indices []int
indexValid func(int) bool
}
func newVectorAssignConstant[D any](value D, indices []int) computeVectorT[D] {
return vectorAssignConstant[D]{
value: value,
indices: indices,
indexValid: computeIndexValid(indices),
}
}
func (compute vectorAssignConstant[D]) resize(newSize int) computeVectorT[D] {
return newVectorAssignConstant[D](compute.value, resizeAssignIndices(newSize, compute.indices))
}
func (compute vectorAssignConstant[D]) assignIndex(index int) (int, bool) {
return index, compute.indexValid(index)
}
func (compute vectorAssignConstant[D]) computeElement(_ int) (result D, ok bool) {
return compute.value, true
}
func newVectorAssignConstantPipeline[D any](value D, indices []int) *pipeline.Pipeline[any] {
var values []D
if n, all := isAll(indices); all {
var p pipeline.Pipeline[any]
index := 0
p.Source(pipeline.NewFunc[any](n, func(size int) (data any, fetched int, err error) {
var result vectorSlice[D]
if index >= n {
return result, 0, nil
}
if index+size > n {
size = n - index
}
if size < len(values) {
values = values[:size]
} else {
for len(values) < size {
values = append(values, value)
}
}
result.cow = cowv
result.indices = make([]int, size)
for i := range result.indices {
result.indices[i] = index + i
}
result.values = values
index += size
return result, size, nil
}))
return &p
}
var p pipeline.Pipeline[any]
index := 0
p.Source(pipeline.NewFunc[any](len(indices), func(size int) (data any, fetched int, err error) {
var result vectorSlice[D]
if index >= len(indices) {
return result, 0, nil
}
if index+size > len(indices) {
size = len(indices) - index
}
if size < len(values) {
values = values[:size]
} else {
for len(values) < size {
values = append(values, value)
}
}
result.cow = cow0 | cowv
result.indices = indices[index : index+size]
result.values = values
index += size
return result, size, nil
}))
return &p
}
func (compute vectorAssignConstant[D]) computePipeline() *pipeline.Pipeline[any] {
return newVectorAssignConstantPipeline(compute.value, compute.indices)
}
type deleteVector[D any] struct {
indices []int
indexValid func(int) bool
}
func newDeleteVector[D any](indices []int) computeVectorT[D] {
return deleteVector[D]{
indices: indices,
indexValid: computeIndexValid(indices),
}
}
func (compute deleteVector[D]) resize(newSize int) computeVectorT[D] {
return newDeleteVector[D](resizeAssignIndices(newSize, compute.indices))
}
func (compute deleteVector[D]) assignIndex(index int) (int, bool) {
return index, compute.indexValid(index)
}
func (_ deleteVector[D]) computeElement(_ int) (result D, ok bool) {
return
}
func (_ deleteVector[D]) computePipeline() *pipeline.Pipeline[any] {
return nil
}
type vectorAssignConstantScalar[D any] struct {
value *scalarReference[D]
indices []int
indexValid func(int) bool
}
func newVectorAssignConstantScalar[D any](value *scalarReference[D], indices []int) computeVectorT[D] {
s := value.get()
if s.optimized() {
if val, ok := s.extractElement(value); ok {
return newVectorAssignConstant[D](val, indices)
}
return newDeleteVector[D](indices)
}
return vectorAssignConstantScalar[D]{
value: value,
indices: indices,
indexValid: computeIndexValid(indices),
}
}
func (compute vectorAssignConstantScalar[D]) resize(newSize int) computeVectorT[D] {
return newVectorAssignConstantScalar[D](compute.value, resizeAssignIndices(newSize, compute.indices))
}
func (compute vectorAssignConstantScalar[D]) assignIndex(index int) (int, bool) {
return index, compute.indexValid(index)
}
func (compute vectorAssignConstantScalar[D]) computeElement(_ int) (result D, ok bool) {
return compute.value.extractElement()
}
func (compute vectorAssignConstantScalar[D]) computePipeline() *pipeline.Pipeline[any] {
if s, sok := compute.value.extractElement(); sok {
return newVectorAssignConstantPipeline(s, compute.indices)
}
return nil
} | functional_Vector_ComputedAssign.go | 0.54698 | 0.439146 | functional_Vector_ComputedAssign.go | starcoder |
package openapi
import (
"encoding/json"
)
// Status The `Status` type defines a logical error model that is suitable for different programming environments, including REST APIs and RPC APIs. It is used by [gRPC](https://github.com/grpc). Each `Status` message contains three pieces of data: error code, error message, and error details. You can find out more about this error model and how to work with it in the [API Design Guide](https://cloud.google.com/apis/design/errors).
type Status struct {
// The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code].
Code *int32 `json:"code,omitempty"`
// A developer-facing error message, which should be in English. Any user-facing error message should be localized and sent in the [google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client.
Message *string `json:"message,omitempty"`
// A list of messages that carry the error details. There is a common set of message types for APIs to use.
Details *[]ProtobufAny `json:"details,omitempty"`
}
// NewStatus instantiates a new Status 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 NewStatus() *Status {
this := Status{}
return &this
}
// NewStatusWithDefaults instantiates a new Status 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 NewStatusWithDefaults() *Status {
this := Status{}
return &this
}
// GetCode returns the Code field value if set, zero value otherwise.
func (o *Status) GetCode() int32 {
if o == nil || o.Code == nil {
var ret int32
return ret
}
return *o.Code
}
// GetCodeOk returns a tuple with the Code field value if set, nil otherwise
// and a boolean to check if the value has been set.
func (o *Status) GetCodeOk() (*int32, bool) {
if o == nil || o.Code == nil {
return nil, false
}
return o.Code, true
}
// HasCode returns a boolean if a field has been set.
func (o *Status) HasCode() bool {
if o != nil && o.Code != nil {
return true
}
return false
}
// SetCode gets a reference to the given int32 and assigns it to the Code field.
func (o *Status) SetCode(v int32) {
o.Code = &v
}
// GetMessage returns the Message field value if set, zero value otherwise.
func (o *Status) GetMessage() string {
if o == nil || o.Message == nil {
var ret string
return ret
}
return *o.Message
}
// GetMessageOk returns a tuple with the Message field value if set, nil otherwise
// and a boolean to check if the value has been set.
func (o *Status) GetMessageOk() (*string, bool) {
if o == nil || o.Message == nil {
return nil, false
}
return o.Message, true
}
// HasMessage returns a boolean if a field has been set.
func (o *Status) HasMessage() bool {
if o != nil && o.Message != nil {
return true
}
return false
}
// SetMessage gets a reference to the given string and assigns it to the Message field.
func (o *Status) SetMessage(v string) {
o.Message = &v
}
// GetDetails returns the Details field value if set, zero value otherwise.
func (o *Status) GetDetails() []ProtobufAny {
if o == nil || o.Details == nil {
var ret []ProtobufAny
return ret
}
return *o.Details
}
// GetDetailsOk returns a tuple with the Details field value if set, nil otherwise
// and a boolean to check if the value has been set.
func (o *Status) GetDetailsOk() (*[]ProtobufAny, bool) {
if o == nil || o.Details == nil {
return nil, false
}
return o.Details, true
}
// HasDetails returns a boolean if a field has been set.
func (o *Status) HasDetails() bool {
if o != nil && o.Details != nil {
return true
}
return false
}
// SetDetails gets a reference to the given []ProtobufAny and assigns it to the Details field.
func (o *Status) SetDetails(v []ProtobufAny) {
o.Details = &v
}
func (o Status) MarshalJSON() ([]byte, error) {
toSerialize := map[string]interface{}{}
if o.Code != nil {
toSerialize["code"] = o.Code
}
if o.Message != nil {
toSerialize["message"] = o.Message
}
if o.Details != nil {
toSerialize["details"] = o.Details
}
return json.Marshal(toSerialize)
}
type NullableStatus struct {
value *Status
isSet bool
}
func (v NullableStatus) Get() *Status {
return v.value
}
func (v *NullableStatus) Set(val *Status) {
v.value = val
v.isSet = true
}
func (v NullableStatus) IsSet() bool {
return v.isSet
}
func (v *NullableStatus) Unset() {
v.value = nil
v.isSet = false
}
func NewNullableStatus(val *Status) *NullableStatus {
return &NullableStatus{value: val, isSet: true}
}
func (v NullableStatus) MarshalJSON() ([]byte, error) {
return json.Marshal(v.value)
}
func (v *NullableStatus) UnmarshalJSON(src []byte) error {
v.isSet = true
return json.Unmarshal(src, &v.value)
} | internal/openapi/model_status.go | 0.793986 | 0.479016 | model_status.go | starcoder |
package codewords
var adjectives = []string{
"abactinal",
"abandoned",
"abashed",
"abasic",
"abatable",
"abatic",
"abaxial",
"abbatial",
"abbreviated",
"abdicable",
"abdominal",
"abdominous",
"abdominovesical",
"abducent",
"abducting",
"abecedarian",
"aberdonian",
"aberrant",
"abeyant",
"abhorrent",
"abiding",
"abient",
"abiogenetic",
"abject",
"abkhaz",
"abkhazian",
"ablated",
"ablative",
"ablaze",
"able",
"abloom",
"ablutionary",
"abnaki",
"abnormal",
"abolishable",
"abolitionary",
"abomasal",
"abominable",
"aboral",
"aboriginal",
"abortifacient",
"abortive",
"aboulic",
"abounding",
"about",
"above",
"aboveboard",
"aboveground",
"abranchial",
"abranchiate",
"abranchious",
"abrasive",
"abreast",
"abridged",
"abroach",
"abroad",
"abrupt",
"abscessed",
"absent",
"absentminded",
"absolute",
"absolutist",
"absolutistic",
"absolved",
"absolvitory",
"absorbable",
"absorbed",
"absorbefacient",
"absorbent",
"absorbing",
"absorptive",
"abstemious",
"abstentious",
"abstinent",
"abstract",
"abstracted",
"abstractionist",
"abstractive",
"abstruse",
"absurd",
"abulic",
"abundant",
"abused",
"abusive",
"abuzz",
"abysmal",
"abyssal",
"academic",
"acanthoid",
"acanthotic",
"acanthous",
"acapnial",
"acapnic",
"acapnotic",
"acarpellous",
"acarpelous",
"acarpous",
"acatalectic",
"acaudal",
"acaudate",
"acaulescent",
"accelerando",
"accelerated",
"accelerative",
"acceleratory",
"accented",
"accentual",
"acceptable",
"acceptant",
"accepted",
"accepting",
"acceptive",
"accessary",
"accessible",
"accessional",
"accessorial",
"accessory",
"accidental",
"accipitrine",
"acclivitous",
"accommodating",
"accommodational",
"accommodative",
"accompanied",
"accompanying",
"accomplishable",
"accomplished",
"accordant",
"according",
"accountable",
"accoutered",
"accoutred",
"accredited",
"accretionary",
"accretive",
"accrued",
"acculturational",
"acculturative",
"accumbent",
"accumulated",
"accumulative",
"accurate",
"accursed",
"accurst",
"accusative",
"accusatorial",
"accusatory",
"accusing",
"accusive",
"accustomed",
"acellular",
"acentric",
"acephalous",
"acerate",
"acerb",
"acerbic",
"acerose",
"acervate",
"acetabular",
"acetic",
"acetonic",
"acetose",
"acetous",
"acetylenic",
"acetylic",
"achaean",
"achenial",
"acheronian",
"acherontic",
"achievable",
"aching",
"achlamydeous",
"achlorhydric",
"achondritic",
"achondroplastic",
"achromatic",
"achromatinic",
"achromatous",
"achromic",
"achromous",
"achy",
"acicular",
"aciculate",
"acid",
"acidic",
"acidimetric",
"acidophilic",
"acidophilous",
"acidotic",
"acidulent",
"acidulous",
"aciduric",
"acinar",
"acinic",
"acinose",
"acinous",
"acknowledgeable",
"acknowledged",
"acned",
"acneiform",
"acold",
"acoustic",
"acoustical",
"acquainted",
"acquiescent",
"acquirable",
"acquired",
"acquisitive",
"acquitted",
"acrid",
"acrimonious",
"acritical",
"acrobatic",
"acrocarpous",
"acrocentric",
"acrogenic",
"acrogenous",
"acromegalic",
"acronymic",
"acronymous",
"acropetal",
"acrophobic",
"acroscopic",
"actable",
"actinal",
"acting",
"actinic",
"actinoid",
"actinometric",
"actinometrical",
"actinomorphic",
"actinomorphous",
"actinomycetal",
"actinomycetous",
"actinomycotic",
"actionable",
"activated",
"activating",
"active",
"activist",
"activistic",
"actual",
"actuarial",
"actuated",
"actuating",
"acuate",
"aculeate",
"aculeated",
"acuminate",
"acute",
"acyclic",
"adactylous",
"adagio",
"adamant",
"adamantine",
"adaptable",
"adaptational",
"adaptative",
"adapted",
"adaptive",
"adaxial",
"addable",
"addible",
"addicted",
"addictive",
"additional",
"additive",
"addlebrained",
"addled",
"addlepated",
"addressable",
"addressed",
"adducent",
"adducting",
"adductive",
"adenoid",
"adenoidal",
"adept",
"adequate",
"adherent",
"adhesive",
"adiabatic",
"adient",
"adipose",
"adjacent",
"adjectival",
"adjective",
"adjudicative",
"adjudicatory",
"adjunct",
"adjunctive",
"adjuratory",
"adjustable",
"adjusted",
"adjustive",
"adjuvant",
"administrable",
"administrative",
"admirable",
"admired",
"admissible",
"admissive",
"admittable",
"admittible",
"admonishing",
"admonitory",
"adnate",
"adnexal",
"adolescent",
"adonic",
"adoptable",
"adopted",
"adoptive",
"adorable",
"adored",
"adoring",
"adorned",
"adpressed",
"adrenal",
"adrenergic",
"adrenocortical",
"adrift",
"adroit",
"adscititious",
"adscript",
"adscripted",
"adsorbable",
"adsorbate",
"adsorbent",
"adsorptive",
"adulatory",
"adult",
"adulterant",
"adulterate",
"adulterated",
"adulterating",
"adulterine",
"adulterous",
"adumbrative",
"adust",
"advance",
"advanced",
"advancing",
"advantageous",
"advective",
"adventitial",
"adventitious",
"adventive",
"adventuresome",
"adventuristic",
"adventurous",
"adverbial",
"adversative",
"adverse",
"advertent",
"advertised",
"advisable",
"advised",
"advisory",
"adynamic",
"aecial",
"aegean",
"aeolian",
"aeolotropic",
"aeonian",
"aerated",
"aerial",
"aeriferous",
"aeriform",
"aerobic",
"aerobiotic",
"aerodynamic",
"aerolitic",
"aerological",
"aeromechanic",
"aeromedical",
"aeronautic",
"aeronautical",
"aerophilatelic",
"aerophilic",
"aerophilous",
"aerosolised",
"aerosolized",
"aery",
"aeschylean",
"aesculapian",
"aesthetic",
"aesthetical",
"aestival",
"aetiologic",
"aetiological",
"afeard",
"afeared",
"afebrile",
"affable",
"affected",
"affecting",
"affectional",
"affectionate",
"affective",
"afferent",
"affiliated",
"affinal",
"affine",
"affined",
"affirmable",
"affirmative",
"affirmatory",
"affixal",
"affixed",
"affixial",
"afflicted",
"afflictive",
"affluent",
"affordable",
"afghan",
"afghani",
"afghanistani",
"afire",
"aflame",
"aflare",
"aflicker",
"afloat",
"aflutter",
"afoot",
"aforementioned",
"aforesaid",
"aforethought",
"afoul",
"afraid",
"african",
"afrikaans",
"afrikaner",
"after",
"aftermost",
"aftershafted",
"agamic",
"agamogenetic",
"agamous",
"agape",
"agaze",
"aged",
"ageing",
"ageless",
"agelong",
"agential",
"agglomerate",
"agglomerated",
"agglomerative",
"agglutinate",
"agglutinative",
"aggravated",
"aggravating",
"aggregate",
"aggregated",
"aggregative",
"aggressive",
"aghast",
"agile",
"aging",
"agitated",
"agitating",
"agitative",
"agleam",
"aglitter",
"aglow",
"agnate",
"agnatic",
"agnostic",
"agnostical",
"agog",
"agonadal",
"agonal",
"agone",
"agonised",
"agonising",
"agonistic",
"agonistical",
"agonized",
"agonizing",
"agoraphobic",
"agranulocytic",
"agraphic",
"agrarian",
"agreeable",
"agreed",
"agrestic",
"agricultural",
"agrobiologic",
"agrobiological",
"agrologic",
"agrological",
"agronomic",
"agronomical",
"aground",
"agrypnotic",
"aguish",
"ahead",
"ahistorical",
"ahorse",
"ahorseback",
"aided",
"ailing",
"aimless",
"airborne",
"aired",
"airheaded",
"airless",
"airlike",
"airsick",
"airtight",
"airworthy",
"airy",
"ajar",
"akimbo",
"akin",
"alabaster",
"alabastrine",
"alacritous",
"alar",
"alarmed",
"alarming",
"alary",
"alaskan",
"alate",
"alated",
"albanian",
"albescent",
"albigensian",
"albinal",
"albinic",
"albinistic",
"albinotic",
"albitic",
"albuminous",
"albuminuric",
"alcalescent",
"alchemic",
"alchemical",
"alchemistic",
"alchemistical",
"alcoholic",
"aldehydic",
"aldermanic",
"aldermanly",
"aleatory",
"alert",
"aleuronic",
"aleutian",
"alexandrian",
"alexic",
"alfresco",
"algal",
"algebraic",
"algebraical",
"algerian",
"algid",
"algoid",
"algolagnic",
"algometric",
"algometrical",
"algonkian",
"algonquian",
"algonquin",
"algophobic",
"algorithmic",
"alien",
"alienable",
"alienated",
"alienating",
"aliform",
"alight",
"aligned",
"aligning",
"alike",
"alimental",
"alimentary",
"alimentative",
"aliphatic",
"aliquot",
"alive",
"alkahestic",
"alkalescent",
"alkalic",
"alkaline",
"alkaloidal",
"alkalotic",
"alkylic",
"allantoic",
"allantoid",
"allargando",
"alleged",
"allegiant",
"allegoric",
"allegorical",
"allegretto",
"allegro",
"allelic",
"allelomorphic",
"allergenic",
"allergic",
"alleviated",
"alleviative",
"alleviatory",
"alliaceous",
"allied",
"alligatored",
"alliterative",
"allocable",
"allocatable",
"allochronic",
"allochthonous",
"allogamous",
"allogeneic",
"allographic",
"allomerous",
"allometric",
"allomorphic",
"allopathic",
"allopatric",
"allophonic",
"allotropic",
"allotropical",
"allotted",
"allover",
"allowable",
"alloyed",
"alluring",
"allusive",
"alluvial",
"allylic",
"almighty",
"alone",
"aloof",
"alopecic",
"alpestrine",
"alpha",
"alphabetic",
"alphabetical",
"alphabetised",
"alphabetized",
"alphameric",
"alphamerical",
"alphanumeric",
"alphanumerical",
"alpine",
"alright",
"alsatian",
"altaic",
"alterable",
"alterative",
"altered",
"alternate",
"alternating",
"alternative",
"altissimo",
"altitudinal",
"altitudinous",
"alto",
"altricial",
"altruistic",
"alular",
"aluminiferous",
"aluminous",
"alveolar",
"alveolate",
"alvine",
"amalgamate",
"amalgamated",
"amalgamative",
"amaranthine",
"amateur",
"amateurish",
"amative",
"amatory",
"amaurotic",
"amazed",
"amazing",
"ambagious",
"ambassadorial",
"amber",
"ambidextrous",
"ambient",
"ambiguous",
"ambitionless",
"ambitious",
"ambivalent",
"ambiversive",
"amblyopic",
"ambrosial",
"ambrosian",
"ambulacral",
"ambulant",
"ambulatory",
"ameban",
"amebic",
"ameboid",
"amebous",
"ameliorating",
"ameliorative",
"amelioratory",
"amenable",
"amendable",
"amendatory",
"amended",
"amenorrheal",
"amenorrheic",
"amenorrhoeal",
"amenorrhoeic",
"amentaceous",
"amentiferous",
"amerciable",
"american",
"amerind",
"amerindic",
"ametabolic",
"ametabolous",
"amethyst",
"amethystine",
"ametropic",
"amharic",
"amiable",
"amicable",
"amidship",
"aminic",
"amino",
"amiss",
"amitotic",
"ammino",
"ammoniac",
"ammoniacal",
"ammoniated",
"ammonitic",
"amnesiac",
"amnesic",
"amnestic",
"amnic",
"amnionic",
"amniotic",
"amoeban",
"amoebic",
"amoeboid",
"amoebous",
"amok",
"amoristic",
"amorous",
"amorphous",
"amort",
"amphibian",
"amphibiotic",
"amphibious",
"amphiprostylar",
"amphiprostyle",
"amphiprotic",
"amphistylar",
"amphitheatric",
"amphitheatrical",
"amphitropous",
"amphoric",
"amphoteric",
"ample",
"ampullar",
"ampullary",
"amuck",
"amused",
"amusing",
"amusive",
"amygdaliform",
"amygdaline",
"amygdaloid",
"amygdaloidal",
"amylaceous",
"amyloid",
"amyloidal",
"amylolytic",
"anabatic",
"anabiotic",
"anabolic",
"anachronic",
"anachronistic",
"anachronous",
"anaclinal",
"anaclitic",
"anacoluthic",
"anadromous",
"anaemic",
"anaerobic",
"anaerobiotic",
"anaesthetic",
"anaglyphic",
"anaglyphical",
"anaglyptic",
"anaglyptical",
"anagogic",
"anagogical",
"anagrammatic",
"anagrammatical",
"anal",
"analeptic",
"analgesic",
"analgetic",
"analog",
"analogical",
"analogous",
"analogue",
"analphabetic",
"analytic",
"analytical",
"analyzable",
"analyzed",
"anamnestic",
"anamorphic",
"anapaestic",
"anapestic",
"anaphasic",
"anaphoric",
"anaphrodisiac",
"anaphylactic",
"anaplastic",
"anarchic",
"anarchical",
"anarchistic",
"anasarcous",
"anastigmatic",
"anastomotic",
"anatomic",
"anatomical",
"anatropous",
"ancestral",
"anchoritic",
"ancient",
"ancillary",
"andalusian",
"andante",
"andantino",
"andean",
"andorran",
"androgenetic",
"androgenic",
"androgenous",
"androgynous",
"anecdotal",
"anecdotic",
"anecdotical",
"anechoic",
"anemic",
"anemographic",
"anemometric",
"anemometrical",
"anemophilous",
"anencephalic",
"anencephalous",
"aneroid",
"anesthetic",
"anestric",
"anestrous",
"aneuploid",
"aneurismal",
"aneurismatic",
"aneurysmal",
"aneurysmatic",
"anfractuous",
"angelic",
"angelical",
"angered",
"anginal",
"anginose",
"anginous",
"angiocarpic",
"angiocarpous",
"angiomatous",
"angiospermous",
"angled",
"anglican",
"anglophilic",
"anglophobic",
"angolan",
"angry",
"anguillan",
"anguine",
"anguished",
"angular",
"angulate",
"anhydrous",
"anicteric",
"anile",
"animal",
"animalistic",
"animate",
"animated",
"animating",
"animatistic",
"animist",
"animistic",
"anionic",
"aniseikonic",
"anisogametic",
"anisogamic",
"anisogamous",
"anisometric",
"anisometropic",
"anisotropic",
"ankylotic",
"annalistic",
"annelid",
"annelidan",
"annexal",
"annexational",
"annihilated",
"annihilating",
"annihilative",
"announced",
"annoyed",
"annoying",
"annual",
"annular",
"annulate",
"annulated",
"annunciatory",
"anodal",
"anodic",
"anodyne",
"anoestrous",
"anomalous",
"anomic",
"anonymous",
"anoperineal",
"anopheline",
"anorectal",
"anorectic",
"anorexic",
"anorexigenic",
"anorthic",
"anorthitic",
"anosmatic",
"anosmic",
"another",
"anoxemic",
"anoxic",
"anserine",
"answerable",
"answering",
"antacid",
"antagonistic",
"antarctic",
"antebellum",
"antecedent",
"antecubital",
"antediluvial",
"antediluvian",
"antemeridian",
"antemortem",
"antenatal",
"antennal",
"antennary",
"antenuptial",
"antepartum",
"antepenultimate",
"anterior",
"anterograde",
"anthelminthic",
"anthelmintic",
"antheral",
"antheridial",
"anthophagous",
"anthophilous",
"anthracitic",
"anthropic",
"anthropical",
"anthropocentric",
"anthropogenetic",
"anthropogenic",
"anthropoid",
"anthropoidal",
"anthropological",
"anthropometric",
"anthropomorphic",
"anthropophagous",
"anti",
"antiadrenergic",
"antiaircraft",
"antiapartheid",
"antibacterial",
"antibiotic",
"antiblack",
"antic",
"anticancer",
"anticholinergic",
"anticipant",
"anticipated",
"anticipative",
"anticipatory",
"anticlimactic",
"anticlimactical",
"anticlinal",
"anticlockwise",
"anticoagulative",
"anticyclonic",
"antidotal",
"antidromic",
"antifertility",
"antifungal",
"antigenic",
"antiguan",
"antiheretical",
"antiknock",
"antiknocking",
"antimagnetic",
"antimicrobial",
"antimicrobic",
"antimonial",
"antimonic",
"antimonious",
"antimonopoly",
"antineoplastic",
"antinomian",
"antiparallel",
"antipathetic",
"antipathetical",
"antipersonnel",
"antiphlogistic",
"antiphonal",
"antiphonary",
"antipodal",
"antipodean",
"antipollution",
"antipyretic",
"antiquarian",
"antiquated",
"antique",
"antisatellite",
"antisemitic",
"antiseptic",
"antisocial",
"antistrophic",
"antisubmarine",
"antitank",
"antithetic",
"antithetical",
"antithyroid",
"antitoxic",
"antitrust",
"antitumor",
"antitumour",
"antitypic",
"antitypical",
"antiviral",
"antlered",
"antonymous",
"antrorse",
"antsy",
"anuran",
"anuretic",
"anuric",
"anurous",
"anxiolytic",
"anxious",
"aoristic",
"aortal",
"aortic",
"apart",
"apathetic",
"apelike",
"aperient",
"aperiodic",
"apetalous",
"aphaeretic",
"aphakic",
"aphanitic",
"aphasic",
"apheretic",
"aphetic",
"aphonic",
"aphoristic",
"aphotic",
"aphrodisiac",
"aphrodisiacal",
"aphyllous",
"apian",
"apiarian",
"apical",
"apiculate",
"apicultural",
"apish",
"apivorous",
"aplacental",
"aplanatic",
"aplitic",
"apneic",
"apnoeic",
"apocalyptic",
"apocalyptical",
"apocarpous",
"apochromatic",
"apocrine",
"apocryphal",
"apocynaceous",
"apodal",
"apodeictic",
"apodictic",
"apodous",
"apogametic",
"apogamic",
"apogamous",
"apogean",
"apolitical",
"apologetic",
"apomictic",
"apomictical",
"aponeurotic",
"apopemptic",
"apophatic",
"apophyseal",
"apoplectic",
"apoplectiform",
"apoplectoid",
"aposiopetic",
"apostate",
"apostolic",
"apostolical",
"apostrophic",
"apothecial",
"apothegmatic",
"apothegmatical",
"apotropaic",
"appalachian",
"appalled",
"appalling",
"appareled",
"apparent",
"apparitional",
"appealable",
"appealing",
"appeasable",
"appeasing",
"appellant",
"appellate",
"appellative",
"appendaged",
"appendant",
"appendicular",
"apperceptive",
"appetent",
"appetising",
"appetitive",
"appetizing",
"applaudable",
"applicable",
"applicative",
"applicatory",
"applied",
"appointed",
"appointive",
"apportionable",
"apportioned",
"apposable",
"apposite",
"appositional",
"appositive",
"appraising",
"appreciable",
"appreciated",
"appreciative",
"apprehended",
"apprehensible",
"apprehensive",
"apprenticed",
"appressed",
"approachable",
"approaching",
"approbative",
"approbatory",
"appropriable",
"appropriate",
"appropriative",
"approved",
"approving",
"approximate",
"approximative",
"appurtenant",
"apractic",
"apraxic",
"apropos",
"apsidal",
"apteral",
"apterous",
"aptitudinal",
"aquacultural",
"aquaphobic",
"aquatic",
"aqueous",
"aquicultural",
"aquiferous",
"aquiline",
"arabian",
"arabic",
"arable",
"araceous",
"arachnidian",
"arachnoid",
"aramaean",
"aramaic",
"aramean",
"araneidal",
"araneidan",
"arawakan",
"arbitrable",
"arbitral",
"arbitrary",
"arbitrational",
"arbitrative",
"arboraceous",
"arborary",
"arboreal",
"arboreous",
"arborescent",
"arboresque",
"arborical",
"arboriform",
"arborous",
"arcadian",
"arcane",
"arced",
"arch",
"archaean",
"archaeologic",
"archaeological",
"archaeozoic",
"archaic",
"archaistic",
"archangelic",
"archangelical",
"archdiocesan",
"archducal",
"archean",
"arched",
"archegonial",
"archegoniate",
"archeologic",
"archeological",
"archeozoic",
"archepiscopal",
"archesporial",
"archetypal",
"archetypical",
"archidiaconal",
"archiepiscopal",
"arching",
"archipelagic",
"architectonic",
"architectural",
"archival",
"archosaurian",
"arciform",
"arco",
"arctic",
"arcuate",
"ardent",
"arduous",
"areal",
"arenaceous",
"arenicolous",
"areolar",
"areolate",
"argent",
"argentic",
"argentiferous",
"argentine",
"argentinian",
"argentous",
"argillaceous",
"argive",
"arguable",
"argumentative",
"arid",
"ariled",
"arillate",
"ariose",
"aristocratic",
"aristocratical",
"aristotelean",
"aristotelian",
"aristotelic",
"arithmetic",
"arithmetical",
"armed",
"armenian",
"armillary",
"arminian",
"armless",
"armlike",
"armored",
"armorial",
"armoured",
"aroid",
"aromatic",
"aroused",
"arranged",
"arrant",
"arrayed",
"arresting",
"arrhythmic",
"arrhythmical",
"arrogant",
"arsenical",
"arsenious",
"artefactual",
"arterial",
"arteriolar",
"arteriovenous",
"artesian",
"artful",
"arthralgic",
"arthritic",
"arthromeric",
"arthropodal",
"arthropodan",
"arthropodous",
"arthrosporic",
"arthrosporous",
"arthurian",
"articled",
"articular",
"articulary",
"articulate",
"articulated",
"articulative",
"articulatory",
"artifactual",
"artificial",
"artiodactyl",
"artiodactylous",
"artistic",
"artless",
"arty",
"arundinaceous",
"aryan",
"asat",
"ascendable",
"ascendant",
"ascendent",
"ascendible",
"ascending",
"ascensional",
"ascensive",
"ascertainable",
"ascertained",
"ascetic",
"ascetical",
"ascitic",
"asclepiadaceous",
"ascocarpous",
"ascomycetous",
"ascosporic",
"ascosporous",
"ascribable",
"aseptic",
"asexual",
"ashamed",
"ashen",
"ashy",
"asian",
"asiatic",
"asinine",
"askance",
"askant",
"askew",
"aslant",
"asleep",
"aslope",
"asocial",
"aspectual",
"asphaltic",
"aspheric",
"aspherical",
"asphyxiated",
"asphyxiating",
"aspirant",
"aspiring",
"asquint",
"assailable",
"assamese",
"assassinated",
"assaultive",
"assentient",
"assertable",
"asserted",
"asserting",
"assertive",
"assessable",
"assiduous",
"assignable",
"assigned",
"assimilable",
"assimilating",
"assimilative",
"assimilatory",
"assistant",
"assisted",
"assistive",
"associable",
"associate",
"associational",
"associative",
"associatory",
"assonant",
"assorted",
"assuasive",
"assumed",
"assuming",
"assumptive",
"assured",
"assurgent",
"assuring",
"astatic",
"asteriated",
"asterisked",
"asterismal",
"asternal",
"asteroid",
"asteroidal",
"asthenic",
"asthmatic",
"astigmatic",
"astir",
"astomatal",
"astomatous",
"astonied",
"astonished",
"astonishing",
"astounded",
"astounding",
"astragalar",
"astral",
"astringent",
"astrocytic",
"astrological",
"astronautic",
"astronautical",
"astronomic",
"astronomical",
"astrophysical",
"astute",
"astylar",
"asunder",
"asymmetric",
"asymmetrical",
"asymptomatic",
"asymptotic",
"asynchronous",
"asyndetic",
"asynergic",
"atactic",
"ataractic",
"ataraxic",
"atavistic",
"ataxic",
"ateleiotic",
"atheist",
"atheistic",
"atheistical",
"athenian",
"atheromatic",
"atheromatous",
"atherosclerotic",
"athirst",
"athletic",
"atilt",
"atlantic",
"atmospheric",
"atmospherical",
"atomic",
"atomistic",
"atomistical",
"atonal",
"atonalistic",
"atonic",
"atoxic",
"atrabilious",
"atrial",
"atrip",
"atrocious",
"atrophic",
"atrophied",
"attachable",
"attached",
"attacking",
"attainable",
"attained",
"attempted",
"attendant",
"attended",
"attentional",
"attentive",
"attenuate",
"attenuated",
"attested",
"attic",
"attired",
"attitudinal",
"attractable",
"attractive",
"attributable",
"attributive",
"attrited",
"attritional",
"atypic",
"atypical",
"auburn",
"auctorial",
"audacious",
"audenesque",
"audible",
"audile",
"audiometric",
"audiovisual",
"auditive",
"auditory",
"augean",
"augitic",
"augmentative",
"augmented",
"august",
"augustan",
"auld",
"aural",
"aureate",
"auric",
"auricular",
"auriculate",
"auriculated",
"auriferous",
"auriform",
"auroral",
"aurorean",
"aurous",
"auscultatory",
"auspicious",
"austenitic",
"austere",
"austral",
"australasian",
"australian",
"austrian",
"austronesian",
"autacoidal",
"autarchic",
"autarchical",
"autarkic",
"autarkical",
"authentic",
"authenticated",
"authorial",
"authorised",
"authoritarian",
"authoritative",
"authorized",
"autistic",
"autobiographic",
"autocatalytic",
"autochthonal",
"autochthonic",
"autochthonous",
"autocratic",
"autodidactic",
"autoecious",
"autoerotic",
"autofluorescent",
"autogamic",
"autogamous",
"autogenetic",
"autogenic",
"autogenous",
"autographed",
"autographic",
"autoicous",
"autoimmune",
"autoloading",
"autologous",
"autolytic",
"automated",
"automatic",
"automatonlike",
"automotive",
"autonomic",
"autonomous",
"autophytic",
"autoplastic",
"autosemantic",
"autosomal",
"autotelic",
"autotomic",
"autotrophic",
"autotypic",
"autumnal",
"auxetic",
"auxiliary",
"auxinic",
"available",
"avaricious",
"avascular",
"avellan",
"avellane",
"avenged",
"average",
"averse",
"aversive",
"avertable",
"avertible",
"avestan",
"avian",
"avid",
"avifaunal",
"avifaunistic",
"avionic",
"avirulent",
"avitaminotic",
"avocado",
"avocational",
"avoidable",
"avowed",
"avuncular",
"awaited",
"awake",
"awakened",
"aware",
"awash",
"away",
"aweary",
"awed",
"aweigh",
"aweless",
"awesome",
"awestricken",
"awestruck",
"awful",
"awheel",
"awing",
"awkward",
"awless",
"awned",
"awninged",
"awnless",
"awny",
"awol",
"awry",
"axenic",
"axial",
"axile",
"axillary",
"axiological",
"axiomatic",
"axiomatical",
"axonal",
"azerbaijani",
"azido",
"azimuthal",
"azoic",
"azonal",
"azonic",
"azotemic",
"azotic",
"azure",
"azygos",
"azygous",
"babelike",
"baboonish",
"babyish",
"babylonian",
"baccate",
"bacchanal",
"bacchanalian",
"bacchantic",
"bacchic",
"bacciferous",
"baccivorous",
"bacillar",
"bacillary",
"bacilliform",
"back",
"backbreaking",
"backed",
"backhand",
"backhanded",
"backless",
"backmost",
"backstage",
"backstair",
"backstairs",
"backswept",
"backward",
"bacteremic",
"bacterial",
"bactericidal",
"bacterioid",
"bacterioidal",
"bacteriologic",
"bacteriological",
"bacteriolytic",
"bacteriophagic",
"bacteriophagous",
"bacteriostatic",
"bacteroid",
"bacteroidal",
"baculiform",
"baffled",
"baffling",
"baggy",
"bahai",
"bahamian",
"bahraini",
"bailable",
"baked",
"baking",
"balanced",
"balconied",
"bald",
"balding",
"baleful",
"balking",
"balky",
"balletic",
"ballistic",
"bally",
"balmy",
"balsamic",
"balsamy",
"baltic",
"balzacian",
"banal",
"banausic",
"bandaged",
"banded",
"bandy",
"baneful",
"banging",
"bangladeshi",
"bankable",
"bankrupt",
"banned",
"banner",
"bantam",
"bantering",
"bantoid",
"bantu",
"baptised",
"baptismal",
"baptistic",
"baptized",
"barbadian",
"barbarian",
"barbaric",
"barbarous",
"barbate",
"barbecued",
"barbed",
"barbellate",
"bardic",
"bare",
"bareback",
"barebacked",
"bared",
"barefaced",
"barefoot",
"barefooted",
"barehanded",
"bareheaded",
"barelegged",
"baric",
"baritone",
"barky",
"barmy",
"barographic",
"barometric",
"barometrical",
"baronial",
"baroque",
"barred",
"barreled",
"barrelled",
"barren",
"barricaded",
"barytic",
"basal",
"basaltic",
"base",
"baseborn",
"based",
"baseless",
"bashful",
"basic",
"basidial",
"basidiomycetous",
"basidiosporous",
"basifixed",
"basilar",
"basilary",
"basilican",
"basinal",
"basined",
"basipetal",
"basiscopic",
"basophilic",
"bass",
"bastard",
"bastardised",
"bastardized",
"bastardly",
"bastioned",
"bated",
"bathetic",
"batholithic",
"batholitic",
"bathyal",
"bathymetric",
"bathymetrical",
"batrachian",
"bats",
"battered",
"battleful",
"battlemented",
"batty",
"batwing",
"bauxitic",
"bavarian",
"bawdy",
"bayesian",
"beaded",
"beadlike",
"beady",
"beaked",
"beakless",
"beaklike",
"beaming",
"beamish",
"beamy",
"bearable",
"bearded",
"beardless",
"beardown",
"bearing",
"bearish",
"beastly",
"beat",
"beatable",
"beaten",
"beatific",
"beatified",
"beauteous",
"beautiful",
"becalmed",
"becoming",
"bedaubed",
"bedded",
"bedewed",
"bedfast",
"bedimmed",
"bedless",
"bedraggled",
"bedrid",
"bedridden",
"beechen",
"beefy",
"beery",
"beethovenian",
"beetle",
"beetling",
"befitting",
"befogged",
"beforehand",
"befouled",
"befuddled",
"beggarly",
"beginning",
"begotten",
"begrimed",
"beguiled",
"beguiling",
"behavioral",
"behaviorist",
"behavioristic",
"behavioural",
"behaviourist",
"behaviouristic",
"beheaded",
"behind",
"behindhand",
"beholden",
"beige",
"belarusian",
"belated",
"belemnitic",
"belgian",
"believable",
"belittled",
"belittling",
"bellbottom",
"belletristic",
"bellicose",
"bellied",
"belligerent",
"bellying",
"bellyless",
"beloved",
"belowground",
"belted",
"beltless",
"beltlike",
"bemused",
"bendable",
"bended",
"benedictine",
"benedictive",
"benedictory",
"benefic",
"beneficed",
"beneficent",
"beneficial",
"beneficiary",
"benevolent",
"bengali",
"benighted",
"benign",
"benignant",
"beninese",
"bent",
"benthal",
"benthic",
"benthonic",
"bentonitic",
"benumbed",
"benzenoid",
"benzoic",
"benzylic",
"bereaved",
"bereft",
"bermudan",
"berried",
"berrylike",
"berserk",
"beseeching",
"besieged",
"besotted",
"bespectacled",
"bespoke",
"bespoken",
"besprent",
"best",
"bestial",
"bestubbled",
"beta",
"betrothed",
"better",
"bettering",
"betting",
"betulaceous",
"bewhiskered",
"bewildered",
"bewitched",
"bewitching",
"bhutanese",
"biannual",
"bias",
"biased",
"biaural",
"biauricular",
"biaxal",
"biaxate",
"biaxial",
"bibbed",
"bibless",
"biblical",
"bibliographic",
"bibliographical",
"bibliolatrous",
"bibliomaniacal",
"bibliophilic",
"bibliopolic",
"bibliothecal",
"bibliothecarial",
"bibliotic",
"bibulous",
"bicameral",
"bicapsular",
"bicentenary",
"bicentennial",
"bicentric",
"bicephalous",
"bichromated",
"bichrome",
"bicipital",
"bicolor",
"bicolored",
"bicolour",
"bicoloured",
"biconcave",
"biconvex",
"bicorn",
"bicornate",
"bicorned",
"bicornuate",
"bicornuous",
"bicuspid",
"bicuspidate",
"bicyclic",
"bicylindrical",
"biddable",
"bidentate",
"bidirectional",
"biedermeier",
"biennial",
"biface",
"bifacial",
"bifid",
"bifilar",
"biflagellate",
"bifocal",
"bifoliate",
"biform",
"bifurcate",
"bifurcated",
"bigamous",
"bigeminal",
"bigeneric",
"bigger",
"biggish",
"bigheaded",
"bighearted",
"bigmouthed",
"bignoniaceous",
"bigoted",
"bilabial",
"bilabiate",
"bilateral",
"bilgy",
"biliary",
"bilinear",
"bilingual",
"bilious",
"billed",
"billiard",
"billion",
"billionth",
"billowing",
"billowy",
"bilobate",
"bilobated",
"bilobed",
"bilocular",
"biloculate",
"bimanual",
"bimestrial",
"bimetal",
"bimetallic",
"bimetallistic",
"bimillenial",
"bimodal",
"bimolecular",
"bimonthly",
"bimorphemic",
"bimotored",
"binary",
"binate",
"binaural",
"bindable",
"binding",
"binocular",
"binomial",
"binominal",
"binuclear",
"binucleate",
"binucleated",
"biocatalytic",
"biochemical",
"bioclimatic",
"biodegradable",
"biogenetic",
"biogenic",
"biogenous",
"biogeographic",
"biogeographical",
"biographic",
"biographical",
"biologic",
"biological",
"biologistic",
"bioluminescent",
"biomedical",
"bionic",
"bionomic",
"bionomical",
"biosynthetic",
"biosystematic",
"biotic",
"biotitic",
"biotypic",
"biovular",
"biparous",
"bipartisan",
"bipartite",
"bipartizan",
"biped",
"bipedal",
"bipinnate",
"bipinnatifid",
"bipolar",
"biquadratic",
"biracial",
"biradial",
"biramous",
"birch",
"birchen",
"birefringent",
"birken",
"bisectional",
"biserrate",
"bisexual",
"bismarckian",
"bismuthal",
"bismuthic",
"bisontine",
"bistered",
"bistred",
"bistroic",
"bisulcate",
"bitchy",
"biting",
"bitter",
"bitterish",
"bittersweet",
"bittie",
"bitty",
"bitumenoid",
"bituminoid",
"bituminous",
"bivalent",
"bivalve",
"bivalved",
"bivariate",
"biweekly",
"biyearly",
"bizarre",
"bizonal",
"blabbermouthed",
"blabby",
"black",
"blackened",
"blackguardly",
"blackish",
"bladderlike",
"bladdery",
"bladed",
"bladelike",
"blae",
"blamable",
"blame",
"blameable",
"blamed",
"blameful",
"blameless",
"blameworthy",
"blanched",
"bland",
"blank",
"blanket",
"blanketed",
"blaring",
"blase",
"blasphemous",
"blasted",
"blastemal",
"blastematic",
"blastemic",
"blasting",
"blastocoelic",
"blastodermatic",
"blastodermic",
"blastogenetic",
"blastomeric",
"blastomycotic",
"blastoporal",
"blastoporic",
"blastospheric",
"blastular",
"blatant",
"blate",
"blazing",
"bleached",
"bleak",
"blear",
"bleary",
"blebbed",
"blebby",
"blemished",
"blended",
"blessed",
"blest",
"blighted",
"blimpish",
"blind",
"blinded",
"blindfold",
"blindfolded",
"blinding",
"blinking",
"blissful",
"blistering",
"blistery",
"blithe",
"blithesome",
"blockaded",
"blockading",
"blocked",
"blockheaded",
"blockish",
"blocky",
"blond",
"blonde",
"bloodcurdling",
"blooded",
"bloodguilty",
"bloodless",
"bloodshot",
"bloodstained",
"bloodsucking",
"bloodthirsty",
"bloody",
"blooming",
"blotched",
"blotchy",
"blotto",
"blown",
"blowsy",
"blowy",
"blowzy",
"blubbery",
"blue",
"blueish",
"bluff",
"bluish",
"blunt",
"blunted",
"blurred",
"blurry",
"blushful",
"blushing",
"blustering",
"blusterous",
"blustery",
"boastful",
"bobtail",
"bobtailed",
"bodacious",
"bodied",
"bodiless",
"bodily",
"bodyless",
"boeotian",
"boffo",
"bogartian",
"boggy",
"bogus",
"bohemian",
"boiled",
"boisterous",
"bold",
"bolivian",
"bolographic",
"bolometric",
"bolshevik",
"bolshevist",
"bolshevistic",
"bolshy",
"bombastic",
"bombproof",
"bondable",
"bone",
"boned",
"boneheaded",
"boneless",
"bonelike",
"boney",
"bonkers",
"bonnie",
"bonny",
"bony",
"bonzer",
"bookable",
"booked",
"bookish",
"boolean",
"booming",
"boon",
"boorish",
"booted",
"bootleg",
"bootless",
"bootlicking",
"boozy",
"boracic",
"borated",
"bordered",
"borderline",
"boreal",
"bored",
"boric",
"boring",
"born",
"boronic",
"boskopoid",
"bosky",
"bosnian",
"bosomed",
"bosomy",
"boss",
"bossy",
"botanic",
"botanical",
"botched",
"botchy",
"both",
"bothered",
"bothersome",
"botonee",
"botonnee",
"botryoid",
"botryoidal",
"botswanan",
"bottom",
"bottomed",
"bottomless",
"bottommost",
"botuliform",
"botulinal",
"bouffant",
"boughed",
"boughless",
"boughten",
"bouldered",
"bouldery",
"bouncing",
"bouncy",
"bound",
"bounded",
"bounden",
"bounderish",
"boundless",
"bounteous",
"bountied",
"bountiful",
"bourgeois",
"boustrophedonic",
"bovid",
"bovine",
"bowed",
"bowelless",
"bowery",
"bowfront",
"bowing",
"bowleg",
"bowlegged",
"boxed",
"boxlike",
"boxy",
"boyish",
"boylike",
"boytrose",
"braced",
"brachial",
"brachiate",
"brachiopod",
"brachiopodous",
"brachycephalic",
"brachycranial",
"brachycranic",
"brachydactylic",
"brachydactylous",
"brachypterous",
"brachyurous",
"bracing",
"brackish",
"bracteal",
"bracteate",
"bracted",
"bracteolate",
"brag",
"braggart",
"bragging",
"braggy",
"brahminic",
"brahminical",
"braided",
"brainish",
"brainless",
"brainsick",
"brainwashed",
"brainy",
"braised",
"braky",
"braless",
"brambly",
"branched",
"branchial",
"branchiate",
"branching",
"branchiopod",
"branchiopodan",
"branchiopodous",
"branchless",
"branchy",
"branded",
"brash",
"brassbound",
"brasslike",
"brassy",
"brattish",
"bratty",
"brave",
"braw",
"brawny",
"brazen",
"brazilian",
"breakable",
"breakaway",
"breakneck",
"breasted",
"breastless",
"breathed",
"breathing",
"breathless",
"breathtaking",
"breeched",
"breeding",
"breezy",
"bregmatic",
"briary",
"bribable",
"brickle",
"brickly",
"bridal",
"bridgeable",
"brief",
"briefless",
"briery",
"bright",
"brilliant",
"brimful",
"brimfull",
"brimless",
"brimming",
"brinded",
"brindle",
"brindled",
"briny",
"brisant",
"brisk",
"bristled",
"bristlelike",
"bristly",
"britannic",
"british",
"briton",
"brittle",
"broached",
"broad",
"broadband",
"broadleaf",
"broadloom",
"broadnosed",
"broadside",
"brobdingnagian",
"brocaded",
"broiled",
"broke",
"broken",
"brokenhearted",
"bromic",
"bromidic",
"bronchial",
"bronchiolar",
"bronchitic",
"bronchoscopic",
"bronze",
"bronzed",
"bronzy",
"brooding",
"broody",
"brotherlike",
"brotherly",
"brown",
"browned",
"brownish",
"bruising",
"brumal",
"brummagem",
"brumous",
"bruneian",
"brunet",
"brunette",
"brushed",
"brushlike",
"brushy",
"brusk",
"brusque",
"brut",
"brutal",
"brute",
"brutish",
"bryophytic",
"bubaline",
"bubbling",
"bubbly",
"bubonic",
"buccal",
"buckram",
"buckshee",
"bucolic",
"buddhist",
"buddhistic",
"budding",
"budgetary",
"buff",
"buffeted",
"buffoonish",
"bugged",
"buggy",
"built",
"buirdly",
"bulbaceous",
"bulbar",
"bulbed",
"bulblike",
"bulbous",
"bulgarian",
"bulging",
"bulgy",
"bulimic",
"bulky",
"bullate",
"bulletproof",
"bullheaded",
"bullish",
"bullnecked",
"bullocky",
"bully",
"bullying",
"bumbling",
"bumpkinly",
"bumptious",
"bumpy",
"bunchy",
"bungaloid",
"bungled",
"bunglesome",
"bungling",
"buoyant",
"burbling",
"burbly",
"burdened",
"burdenless",
"burdensome",
"bureaucratic",
"burglarious",
"burglarproof",
"buried",
"burked",
"burled",
"burlesque",
"burly",
"burmese",
"burnable",
"burned",
"burning",
"burnished",
"burnt",
"burred",
"burrlike",
"burry",
"bursal",
"bursiform",
"burundi",
"burundian",
"bush",
"bushed",
"bushwhacking",
"bushy",
"businesslike",
"bust",
"busted",
"bustling",
"busty",
"busy",
"busybodied",
"butch",
"butcherly",
"buteonine",
"butterfingered",
"buttery",
"buttoned",
"buttonlike",
"buttony",
"buttressed",
"butyraceous",
"butyric",
"buxom",
"buzzing",
"bygone",
"bypast",
"byzantine",
"cabalistic",
"cachectic",
"cackly",
"cacodaemonic",
"cacodemonic",
"cacodylic",
"cacogenic",
"cacophonic",
"cacophonous",
"cacuminal",
"cadastral",
"cadaveric",
"cadaverous",
"caddish",
"cadenced",
"cadent",
"caducean",
"caducous",
"caecal",
"caecilian",
"caesarean",
"caesarian",
"caespitose",
"caesural",
"caffeinic",
"cagey",
"cagy",
"cairned",
"caitiff",
"calamitous",
"calando",
"calcaneal",
"calcareous",
"calced",
"calceiform",
"calceolate",
"calcic",
"calcicolous",
"calciferous",
"calcific",
"calcifugous",
"calcitic",
"calculable",
"calculated",
"calculating",
"calculative",
"calculous",
"calcuttan",
"calefacient",
"calefactive",
"calefactory",
"calendered",
"calendric",
"calendrical",
"calibrated",
"calico",
"calicular",
"californian",
"caliginous",
"calisthenic",
"callable",
"caller",
"calligraphic",
"calligraphical",
"callipygian",
"callipygous",
"callithumpian",
"callous",
"calloused",
"callow",
"calm",
"caloric",
"calorifacient",
"calorific",
"calorimetric",
"calumniatory",
"calumnious",
"calvinist",
"calvinistic",
"calvinistical",
"calyceal",
"calycinal",
"calycine",
"calycled",
"calycular",
"calyculate",
"calyptrate",
"cambial",
"cambodian",
"cambrian",
"cameroonian",
"camouflaged",
"camp",
"campanular",
"campanulate",
"campanulated",
"campestral",
"camphoraceous",
"camphorated",
"camphoric",
"campy",
"campylotropous",
"canadian",
"canalicular",
"canaliculate",
"canary",
"cancellate",
"cancellated",
"cancelled",
"cancellous",
"cancerous",
"cancroid",
"candent",
"candescent",
"candid",
"candied",
"canescent",
"canicular",
"canine",
"cankerous",
"canned",
"cannibalic",
"cannibalistic",
"cannular",
"canny",
"canonic",
"canonical",
"canonised",
"canonist",
"canonized",
"canopied",
"canorous",
"cantabile",
"cantankerous",
"canted",
"cantering",
"cantonal",
"canty",
"capable",
"capacious",
"capacitive",
"caparisoned",
"capetian",
"capillary",
"capital",
"capitalist",
"capitalistic",
"capitate",
"capitular",
"capitulary",
"cappadocian",
"capped",
"capricious",
"caprine",
"capsular",
"capsulate",
"capsulated",
"captious",
"captivated",
"captivating",
"captive",
"caramel",
"carangid",
"carbocyclic",
"carbolated",
"carbonaceous",
"carbonated",
"carbonic",
"carboniferous",
"carbonous",
"carbonyl",
"carbonylic",
"carboxyl",
"carboxylic",
"carbuncled",
"carbuncular",
"carcinogenic",
"carcinomatous",
"cardboard",
"cardiac",
"cardinal",
"cardiographic",
"cardiologic",
"cardiopulmonary",
"cardiovascular",
"carefree",
"careful",
"careless",
"careworn",
"carinal",
"carinate",
"carinated",
"caring",
"carious",
"carmelite",
"carminative",
"carmine",
"carnal",
"carnassial",
"carnation",
"carnivorous",
"carolean",
"caroline",
"carolingian",
"carotid",
"carousing",
"carpal",
"carpellary",
"carpellate",
"carpetbag",
"carpetbagging",
"carpeted",
"carpophagous",
"carposporic",
"carposporous",
"carroty",
"carsick",
"cartesian",
"carthaginian",
"carthusian",
"cartilaginous",
"cartographic",
"cartographical",
"caruncular",
"carunculate",
"carunculated",
"carunculous",
"carved",
"carven",
"casebook",
"cased",
"caseous",
"cashable",
"cashed",
"cassocked",
"casteless",
"castellated",
"castled",
"castrated",
"casual",
"casuistic",
"casuistical",
"catabatic",
"catabolic",
"catachrestic",
"catachrestical",
"cataclinal",
"cataclysmal",
"cataclysmic",
"catacorner",
"catadromous",
"catalan",
"catalatic",
"catalectic",
"cataleptic",
"catalytic",
"catamenial",
"cataphatic",
"cataphoretic",
"cataplastic",
"catapultian",
"catapultic",
"catarrhal",
"catarrhine",
"catarrhinian",
"catastrophic",
"catatonic",
"catching",
"catchpenny",
"catchy",
"catechetic",
"catechetical",
"catechismal",
"catechistic",
"categorematic",
"categorial",
"categoric",
"categorical",
"categorised",
"categorized",
"catenulate",
"catercorner",
"cathartic",
"cathectic",
"cathedral",
"cathodic",
"catholic",
"cationic",
"catkinate",
"catoptric",
"catoptrical",
"cattish",
"catty",
"caucasian",
"caucasic",
"caucasoid",
"caudal",
"caudate",
"caudated",
"caulescent",
"cauline",
"caulked",
"causal",
"causative",
"causeless",
"caustic",
"cautionary",
"cautious",
"cavalier",
"cavernous",
"cavitied",
"ceaseless",
"cecal",
"cedarn",
"ceilinged",
"celebrated",
"celebratory",
"celestial",
"celiac",
"celibate",
"cellular",
"celluloid",
"cellulosid",
"celtic",
"cementitious",
"cenobitic",
"cenobitical",
"cenogenetic",
"cenozoic",
"censored",
"censorial",
"censorious",
"censurable",
"centenarian",
"centenary",
"centennial",
"center",
"centered",
"centesimal",
"centigrade",
"central",
"centralised",
"centralising",
"centralist",
"centralistic",
"centralized",
"centralizing",
"centric",
"centrical",
"centrifugal",
"centripetal",
"centrist",
"centroidal",
"centromeric",
"centrosomic",
"centrosymmetric",
"cephalic",
"cephalopod",
"cephalopodan",
"ceramic",
"cercarial",
"cereal",
"cerebellar",
"cerebral",
"cerebrospinal",
"cerebrovascular",
"ceremonial",
"ceremonious",
"ceric",
"cerise",
"cernuous",
"cerous",
"certain",
"certifiable",
"certificated",
"certificatory",
"certified",
"cerulean",
"ceruminous",
"cervical",
"cervine",
"cesarean",
"cesarian",
"cespitose",
"cetacean",
"cetaceous",
"ceylonese",
"chadian",
"chaetal",
"chaetognathan",
"chaetognathous",
"chafed",
"chafflike",
"chaffy",
"chagrined",
"chained",
"chainlike",
"chaldaean",
"chaldean",
"chaldee",
"chalky",
"challengeable",
"challenging",
"chalybeate",
"chambered",
"champion",
"champleve",
"chance",
"chanceful",
"chancroidal",
"chancrous",
"chancy",
"changeable",
"changed",
"changeful",
"changeless",
"changing",
"chanted",
"chantlike",
"chaotic",
"chapfallen",
"chapleted",
"chapped",
"characteristic",
"characterless",
"charcoal",
"chargeable",
"charged",
"charismatic",
"charitable",
"charmed",
"charming",
"charnel",
"chartaceous",
"chartered",
"chartless",
"chartreuse",
"chary",
"chasidic",
"chassidic",
"chaste",
"chatoyant",
"chatty",
"chauvinistic",
"cheap",
"cheapjack",
"cheating",
"chechen",
"checked",
"checkered",
"cheeky",
"cheerful",
"cheering",
"cheerless",
"cheery",
"cheeselike",
"cheeseparing",
"cheesy",
"chelate",
"chelated",
"cheliceral",
"chelicerate",
"chelicerous",
"cheliferous",
"chelonian",
"chemic",
"chemical",
"chemisorptive",
"chemoreceptive",
"chemosorptive",
"chequered",
"cherished",
"cherry",
"cherty",
"cherubic",
"chestnut",
"chesty",
"chewable",
"chewy",
"chian",
"chiasmal",
"chiasmatic",
"chiasmic",
"chic",
"chichi",
"chicken",
"chickenhearted",
"chief",
"chilblained",
"childbearing",
"childish",
"childless",
"childlike",
"childly",
"chilean",
"chiliastic",
"chilling",
"chilly",
"chimeral",
"chimeric",
"chimerical",
"chinchy",
"chinese",
"chinked",
"chinless",
"chintzy",
"chippendale",
"chipper",
"chiromantic",
"chirpy",
"chiseled",
"chitinous",
"chivalric",
"chivalrous",
"chlamydeous",
"chlamydial",
"chlorophyllose",
"chlorophyllous",
"chlorotic",
"chockablock",
"chockful",
"choice",
"choked",
"choky",
"choleraic",
"choleric",
"cholinergic",
"chondritic",
"choosey",
"choosy",
"chopfallen",
"chopped",
"choppy",
"choragic",
"choral",
"chordal",
"chordate",
"choreographic",
"choric",
"chorionic",
"christian",
"christianly",
"christless",
"christlike",
"christly",
"christological",
"chromatic",
"chromatinic",
"chromatographic",
"chromosomal",
"chronic",
"chronological",
"chthonian",
"chthonic",
"chubby",
"chuffed",
"chummy",
"chunky",
"churchgoing",
"churchillian",
"churchly",
"churlish",
"churning",
"churrigueresco",
"churrigueresque",
"chylaceous",
"chylifactive",
"chylifactory",
"chyliferous",
"chylific",
"chylous",
"cilial",
"ciliary",
"ciliate",
"ciliated",
"cimmerian",
"cinematic",
"cinerary",
"cinnabar",
"circadian",
"circinate",
"circuitous",
"circular",
"circulating",
"circulative",
"circulatory",
"circumboreal",
"circumferent",
"circumferential",
"circumlocutious",
"circumlocutory",
"circumpolar",
"circumscribed",
"circumspect",
"circumstantial",
"cisalpine",
"cislunar",
"cismontane",
"cissy",
"citified",
"citric",
"citrous",
"cityfied",
"citywide",
"civic",
"civil",
"civilian",
"civilised",
"civilized",
"clad",
"clairvoyant",
"clamant",
"clamatorial",
"clammy",
"clamorous",
"clandestine",
"clanging",
"clangorous",
"clanking",
"clannish",
"clarifying",
"clarion",
"clashing",
"classic",
"classical",
"classicistic",
"classifiable",
"classificatory",
"classified",
"classless",
"classy",
"clastic",
"clathrate",
"clattery",
"clausal",
"claustrophobic",
"clawed",
"clawlike",
"clayey",
"clean",
"cleanable",
"cleanly",
"cleansing",
"clear",
"cleared",
"clearheaded",
"cleavable",
"cleft",
"cleistogamic",
"cleistogamous",
"clement",
"clenched",
"clerical",
"clever",
"cliched",
"climactic",
"climatic",
"climatical",
"climbable",
"clinched",
"clinical",
"clinking",
"clinquant",
"clipped",
"cliquish",
"clitoral",
"clitoric",
"cloaked",
"clockwise",
"cloddish",
"clogged",
"clogging",
"cloggy",
"cloisonne",
"cloistered",
"cloistral",
"clonal",
"clonic",
"close",
"closed",
"closefisted",
"closelipped",
"closemouthed",
"closing",
"clothed",
"clothesless",
"clotted",
"clouded",
"cloudless",
"cloudlike",
"cloudy",
"cloven",
"clownish",
"clownlike",
"cloying",
"cloze",
"clubable",
"clubbable",
"clubbish",
"clubby",
"clubfooted",
"clueless",
"clumsy",
"clunky",
"clustered",
"cluttered",
"clxv",
"clxx",
"clxxv",
"clxxx",
"coagulable",
"coagulate",
"coagulated",
"coalesced",
"coalescent",
"coalescing",
"coarctate",
"coarse",
"coarsened",
"coastal",
"coastwise",
"coated",
"coaxal",
"coaxial",
"coaxing",
"cobwebby",
"coccal",
"coccoid",
"coccygeal",
"cochlear",
"cockamamie",
"cockamamy",
"cockeyed",
"cockney",
"cocksure",
"cocky",
"codified",
"coeducational",
"coeliac",
"coenobitic",
"coenobitical",
"coequal",
"coercive",
"coetaneous",
"coeval",
"coexistent",
"coexisting",
"coextensive",
"cogent",
"cogged",
"cogitable",
"cogitative",
"cognate",
"cognisable",
"cognisant",
"cognitive",
"cognizable",
"cognizant",
"cognoscible",
"coherent",
"cohesive",
"coiled",
"coiling",
"coincident",
"coincidental",
"coinciding",
"coital",
"cold",
"coldhearted",
"coleridgean",
"coleridgian",
"colicky",
"collaborative",
"collagenic",
"collagenous",
"collapsable",
"collapsible",
"collarless",
"collateral",
"collect",
"collectable",
"collected",
"collectible",
"collective",
"collectivised",
"collectivist",
"collectivistic",
"collectivized",
"collegial",
"collegiate",
"collinear",
"colloidal",
"colloquial",
"collusive",
"colombian",
"colonial",
"colonic",
"colonised",
"colonized",
"colonnaded",
"color",
"colorectal",
"colored",
"colorfast",
"colorful",
"colorimetric",
"colorimetrical",
"colorless",
"colossal",
"colour",
"coloured",
"colourful",
"colourless",
"coltish",
"columbian",
"columnar",
"columned",
"columniform",
"columnlike",
"comal",
"comate",
"comatose",
"combatant",
"combative",
"combed",
"combinable",
"combinational",
"combinative",
"combinatorial",
"combinatory",
"combined",
"comburant",
"comburent",
"combustible",
"combustive",
"comely",
"comestible",
"cometary",
"cometic",
"comfortable",
"comforted",
"comforting",
"comfortless",
"comfy",
"comic",
"comical",
"coming",
"commanding",
"commemorating",
"commemorative",
"commendable",
"commensal",
"commensurable",
"commensurate",
"commercial",
"commercialised",
"commercialized",
"comminatory",
"commiserative",
"commissioned",
"committed",
"commodious",
"common",
"commonplace",
"commonsense",
"commonsensible",
"commonsensical",
"communal",
"communicable",
"communicational",
"communicative",
"communicatory",
"communist",
"communistic",
"commutable",
"commutative",
"comose",
"compact",
"companionable",
"companionate",
"comparable",
"comparative",
"compartmental",
"compartmented",
"compassionate",
"compatible",
"compelling",
"compendious",
"compensable",
"compensated",
"competent",
"competitive",
"competitory",
"complacent",
"complaining",
"complaintive",
"complaisant",
"complemental",
"complementary",
"complete",
"completed",
"completing",
"complex",
"compliant",
"complicated",
"complimentary",
"composed",
"composite",
"compositional",
"compound",
"compounded",
"comprehended",
"comprehendible",
"comprehensible",
"comprehensive",
"compressed",
"compressible",
"compromising",
"compulsive",
"compulsory",
"computable",
"computational",
"comradely",
"concave",
"concealed",
"concealing",
"conceited",
"conceivable",
"concentrated",
"concentric",
"concentrical",
"conceptional",
"conceptive",
"conceptual",
"conceptualistic",
"concerned",
"concerted",
"concessive",
"conciliable",
"conciliative",
"conciliatory",
"concise",
"concluded",
"concluding",
"conclusive",
"concomitant",
"concordant",
"concrete",
"concretistic",
"concupiscent",
"concurrent",
"concurring",
"condemnable",
"condemnatory",
"condemning",
"condescending",
"condign",
"conditional",
"conditioned",
"condolent",
"conducive",
"conductive",
"condylar",
"conelike",
"confederate",
"confederative",
"confident",
"confidential",
"confiding",
"configurational",
"configured",
"confined",
"confining",
"confirmable",
"confirmative",
"confirmatory",
"confirmed",
"confirming",
"confiscate",
"conflicting",
"confluent",
"conformable",
"conforming",
"conformist",
"confounded",
"confounding",
"confrontational",
"confucian",
"confusable",
"confused",
"confusing",
"confutable",
"confutative",
"congealed",
"congeneric",
"congenerical",
"congenerous",
"congenial",
"congenital",
"congested",
"congestive",
"conglomerate",
"congolese",
"congratulatory",
"congregational",
"congressional",
"congruent",
"congruous",
"conic",
"conical",
"coniferous",
"conjectural",
"conjoined",
"conjoint",
"conjugal",
"conjugate",
"conjugated",
"conjunct",
"conjunctival",
"conjunctive",
"connate",
"connatural",
"connected",
"connective",
"conniving",
"connotational",
"connotative",
"connubial",
"conquerable",
"consanguine",
"consanguineal",
"consanguineous",
"conscienceless",
"conscientious",
"conscionable",
"conscious",
"consecrate",
"consecrated",
"consecutive",
"consensual",
"consentaneous",
"consentient",
"consenting",
"consequent",
"consequential",
"conservative",
"conserved",
"considerable",
"considerate",
"considered",
"consistent",
"consolable",
"consolatory",
"consolidated",
"consolidative",
"consoling",
"consonant",
"consonantal",
"conspecific",
"conspicuous",
"conspirative",
"conspiratorial",
"constant",
"constipated",
"constituent",
"constituted",
"constitutional",
"constitutive",
"constrained",
"constraining",
"constricted",
"constricting",
"constrictive",
"constructive",
"consubstantial",
"consular",
"consultative",
"consultatory",
"consultive",
"consumable",
"consuming",
"consummate",
"consummated",
"consumptive",
"contagious",
"contained",
"contaminated",
"contaminating",
"contaminative",
"contemplative",
"contemporaneous",
"contemporary",
"contemptible",
"contemptuous",
"content",
"contented",
"contentious",
"conterminous",
"contestable",
"contested",
"contextual",
"contiguous",
"continent",
"continental",
"contingent",
"continual",
"continuant",
"continued",
"continuing",
"continuous",
"contorted",
"contraband",
"contrabass",
"contraceptive",
"contraclockwise",
"contractable",
"contracted",
"contractile",
"contractual",
"contradictory",
"contralateral",
"contralto",
"contrapuntal",
"contrarious",
"contrary",
"contrasting",
"contrastive",
"contrasty",
"contributing",
"contributive",
"contributory",
"contrite",
"contrived",
"controllable",
"controlled",
"controlling",
"controversial",
"contumacious",
"contumelious",
"convalescent",
"convenient",
"conventional",
"conventual",
"convergent",
"conversant",
"conversational",
"converse",
"convertible",
"convex",
"conveyable",
"convinced",
"convincible",
"convincing",
"convivial",
"convolute",
"convoluted",
"convulsive",
"cooccurring",
"cooked",
"cool",
"coolheaded",
"cooperative",
"coordinate",
"coordinated",
"coordinating",
"coordinative",
"copacetic",
"copasetic",
"copernican",
"copesetic",
"copesettic",
"copious",
"coplanar",
"coppery",
"coptic",
"copular",
"copulative",
"copulatory",
"copyrighted",
"coquettish",
"coral",
"corbelled",
"cordate",
"corded",
"cordial",
"cordiform",
"cordless",
"coreferent",
"coreferential",
"coriaceous",
"corinthian",
"corked",
"corking",
"corky",
"cormose",
"cormous",
"corneal",
"corned",
"corneous",
"cornered",
"cornish",
"corny",
"coronary",
"coroneted",
"corporal",
"corporate",
"corporatist",
"corporeal",
"corpulent",
"corpuscular",
"correct",
"correctable",
"corrected",
"correctional",
"corrective",
"correlate",
"correlated",
"correlational",
"correlative",
"correspondent",
"corresponding",
"corrigible",
"corroborant",
"corroborative",
"corroboratory",
"corroded",
"corrosive",
"corrugated",
"corrupt",
"corrupted",
"corruptible",
"corrupting",
"corruptive",
"corsican",
"cortical",
"corticifugal",
"corticipetal",
"corticoafferent",
"corticoefferent",
"corticofugal",
"coruscant",
"corvine",
"corymbose",
"coseismal",
"coseismic",
"cosher",
"cosignatory",
"cosmetic",
"cosmic",
"cosmogenic",
"cosmogonic",
"cosmogonical",
"cosmologic",
"cosmological",
"cosmopolitan",
"costal",
"costate",
"costive",
"costless",
"costly",
"costumed",
"cosy",
"coterminous",
"cottony",
"cotyloid",
"cotyloidal",
"couchant",
"countable",
"counter",
"counteractive",
"counterbalanced",
"counterfactual",
"counterfeit",
"counterpoised",
"countertenor",
"counterterror",
"countless",
"countrified",
"countryfied",
"countrywide",
"countywide",
"coupled",
"courageous",
"courteous",
"courtly",
"cousinly",
"couth",
"couthie",
"couthy",
"covalent",
"covariant",
"covered",
"covert",
"coveted",
"covetous",
"cowardly",
"cowled",
"cozy",
"crabbed",
"crabby",
"crabwise",
"crack",
"crackbrained",
"cracked",
"crackers",
"cracking",
"crackle",
"crafty",
"cragfast",
"cragged",
"craggy",
"cramped",
"cranial",
"craniometric",
"craniometrical",
"crank",
"cranky",
"crannied",
"crappy",
"crapulent",
"crapulous",
"crashing",
"crass",
"craved",
"craven",
"crazed",
"crazy",
"creaky",
"creamy",
"creaseless",
"creaseproof",
"creative",
"credal",
"credentialled",
"credible",
"creditable",
"credited",
"creditworthy",
"credulous",
"creedal",
"creepy",
"crenate",
"crenated",
"crenulate",
"crenulated",
"creole",
"crepuscular",
"crescendo",
"crescent",
"cresson",
"crested",
"crestfallen",
"cretaceous",
"cretinous",
"criminal",
"criminative",
"criminatory",
"criminological",
"crimson",
"cringing",
"crinkled",
"crinkly",
"crinoid",
"crippled",
"crippling",
"crisp",
"crispate",
"crispy",
"crisscross",
"crisscrossed",
"criterial",
"criterional",
"critical",
"croaky",
"croatian",
"crocked",
"crocketed",
"cromwellian",
"crookback",
"crookbacked",
"crooked",
"cropped",
"cross",
"crossbred",
"crossed",
"crosshatched",
"crosstown",
"crosswise",
"crotchety",
"croupy",
"crowded",
"crowing",
"crowned",
"crowning",
"crownless",
"crucial",
"cruciate",
"cruciferous",
"cruciform",
"cruddy",
"crude",
"cruel",
"crumbly",
"crummy",
"crumpled",
"crural",
"crushed",
"crushing",
"crustacean",
"crustaceous",
"crustal",
"crusted",
"crustlike",
"crustose",
"crusty",
"crying",
"cryogenic",
"cryonic",
"cryptanalytic",
"cryptic",
"cryptical",
"cryptobiotic",
"cryptogamic",
"cryptogamous",
"cryptographic",
"cryptographical",
"cryptologic",
"cryptological",
"crystalised",
"crystalized",
"crystalline",
"crystallised",
"crystallized",
"ctenoid",
"cuban",
"cubelike",
"cubic",
"cubical",
"cubiform",
"cubist",
"cubistic",
"cubital",
"cuboid",
"cuboidal",
"cucurbitaceous",
"cuddlesome",
"cuddly",
"culinary",
"culpable",
"cultivable",
"cultivatable",
"cultivated",
"cultural",
"cultured",
"cumbersome",
"cumbrous",
"cumulative",
"cumuliform",
"cumulous",
"cuneal",
"cuneate",
"cuneiform",
"cunning",
"cuplike",
"cupric",
"cuprous",
"cupular",
"cupulate",
"curable",
"curative",
"curatorial",
"curdled",
"cured",
"curious",
"curled",
"curling",
"curly",
"curmudgeonly",
"current",
"curricular",
"currish",
"cursed",
"cursive",
"cursorial",
"cursory",
"curst",
"curt",
"curtained",
"curtainless",
"curtal",
"curvaceous",
"curved",
"curvey",
"curvilineal",
"curvilinear",
"curving",
"curvy",
"cushioned",
"cushiony",
"cushy",
"cuspate",
"cuspated",
"cusped",
"cuspidal",
"cuspidate",
"cuspidated",
"cussed",
"custodial",
"custom",
"customary",
"cutaneal",
"cutaneous",
"cute",
"cuticular",
"cuttable",
"cutthroat",
"cutting",
"cxlv",
"cxxv",
"cxxx",
"cxxxv",
"cyan",
"cyanobacterial",
"cyanogenetic",
"cyanogenic",
"cyanophyte",
"cybernetic",
"cyclic",
"cyclical",
"cycloid",
"cycloidal",
"cyclonal",
"cyclonic",
"cyclonical",
"cyclopean",
"cyclothymic",
"cylindric",
"cylindrical",
"cymose",
"cynical",
"cyprian",
"cyprinid",
"cyprinoid",
"cypriot",
"cypriote",
"cyrillic",
"cystic",
"cytogenetic",
"cytogenetical",
"cytokinetic",
"cytologic",
"cytological",
"cytolytic",
"cytomegalic",
"cytopathogenic",
"cytophotometric",
"cytoplasmatic",
"cytoplasmic",
"cytoplastic",
"cytotoxic",
"czarist",
"czaristic",
"czech",
"czechoslovakian",
"dabbled",
"dacitic",
"dactylic",
"daedal",
"daft",
"daily",
"dainty",
"daisylike",
"dalmatian",
"damaged",
"damaging",
"damascene",
"damask",
"damn",
"damnable",
"damnatory",
"damned",
"damning",
"damp",
"dampish",
"danceable",
"dandified",
"dandy",
"dandyish",
"dangerous",
"danish",
"dank",
"dantean",
"dantesque",
"dapper",
"dappled",
"daredevil",
"daring",
"dark",
"darkened",
"darkening",
"darkish",
"darkling",
"darling",
"darned",
"darwinian",
"dashed",
"dashing",
"dastard",
"dastardly",
"datable",
"dateable",
"dated",
"dateless",
"daughterly",
"daunted",
"daunting",
"dauntless",
"daylong",
"dazed",
"dazzled",
"dazzling",
"dead",
"deadened",
"deadening",
"deadlocked",
"deadly",
"deadpan",
"deaf",
"deafened",
"deafening",
"dear",
"deathless",
"deathlike",
"deathly",
"debased",
"debasing",
"debatable",
"debauched",
"debile",
"debilitated",
"debilitating",
"debilitative",
"debonair",
"debonaire",
"deboned",
"debonnaire",
"decadent",
"decalescent",
"decapitated",
"decasyllabic",
"decayable",
"decayed",
"deceased",
"deceitful",
"decent",
"decentralised",
"decentralising",
"decentralized",
"decentralizing",
"deceptive",
"decided",
"deciding",
"deciduous",
"decimal",
"decipherable",
"deciphered",
"decisive",
"deckled",
"declamatory",
"declarable",
"declarative",
"declaratory",
"declared",
"declassified",
"declivitous",
"decollete",
"decomposable",
"decompositional",
"decompound",
"deconsecrated",
"decorated",
"decorative",
"decorous",
"decreased",
"decreasing",
"decreed",
"decrepit",
"decrescendo",
"decumbent",
"decurved",
"decussate",
"dedicated",
"deducible",
"deductible",
"deductive",
"deep",
"deepening",
"defamatory",
"defeasible",
"defeated",
"defective",
"defenceless",
"defendable",
"defending",
"defenseless",
"defensible",
"defensive",
"deferent",
"deferential",
"defervescent",
"defiant",
"deficient",
"defiled",
"definable",
"defined",
"definite",
"definitive",
"deflated",
"deflationary",
"deflective",
"defoliate",
"defoliated",
"deformational",
"deformed",
"deft",
"defunct",
"degage",
"degenerate",
"degenerative",
"degraded",
"degrading",
"degressive",
"dehiscent",
"dehumanised",
"dehumanized",
"dehydrated",
"deictic",
"deific",
"deist",
"deistic",
"dejected",
"delayed",
"delectable",
"deleterious",
"deliberate",
"deliberative",
"delible",
"delicate",
"delicious",
"delighted",
"delightful",
"delimited",
"delineate",
"delineated",
"delineative",
"delinquent",
"deliquescent",
"delirious",
"deliverable",
"delphian",
"delphic",
"deltoid",
"delusional",
"delusive",
"delusory",
"deluxe",
"demagogic",
"demagogical",
"demanding",
"demeaning",
"demented",
"democratic",
"demode",
"demographic",
"demolished",
"demoniac",
"demoniacal",
"demonic",
"demonstrable",
"demonstrated",
"demonstrative",
"demoralised",
"demoralising",
"demoralized",
"demoralizing",
"demosthenic",
"demotic",
"demulcent",
"demure",
"demythologised",
"demythologized",
"denary",
"denatured",
"denaturised",
"denaturized",
"dendriform",
"dendritic",
"dendroid",
"dendroidal",
"deniable",
"denigrating",
"denigrative",
"denigratory",
"denominational",
"denotative",
"denotive",
"dense",
"dental",
"dentate",
"dented",
"denticulate",
"denudate",
"denuded",
"denumerable",
"denunciative",
"denunciatory",
"departed",
"departmental",
"dependable",
"dependant",
"dependent",
"depicted",
"depictive",
"depilatory",
"depilous",
"depletable",
"depleted",
"deplorable",
"depopulated",
"depraved",
"deprecating",
"deprecative",
"deprecatory",
"depreciating",
"depreciative",
"depreciatory",
"depressant",
"depressed",
"depressing",
"deprived",
"deranged",
"derelict",
"derisive",
"derisory",
"derivable",
"derivational",
"derivative",
"derived",
"dermal",
"dermatologic",
"dermatological",
"dermic",
"derogative",
"derogatory",
"descendant",
"descendent",
"descending",
"describable",
"described",
"descriptive",
"desecrated",
"desegrated",
"desensitising",
"desensitizing",
"deserted",
"deserved",
"deserving",
"desiccate",
"desiccated",
"designate",
"designative",
"designed",
"designing",
"desirable",
"desired",
"desirous",
"deskbound",
"desolate",
"despairing",
"desperate",
"despicable",
"despised",
"despiteful",
"despoiled",
"despondent",
"despotic",
"despotical",
"destined",
"destitute",
"destroyable",
"destroyed",
"destructible",
"destructive",
"desultory",
"detachable",
"detached",
"detailed",
"detectable",
"detected",
"detergent",
"determinable",
"determinant",
"determinate",
"determinative",
"determined",
"determining",
"deterministic",
"deterrent",
"detersive",
"detestable",
"detested",
"detonative",
"detractive",
"detrimental",
"deuced",
"deuteranopic",
"devalued",
"devastating",
"developed",
"developing",
"developmental",
"deviant",
"deviate",
"devilish",
"devious",
"devoid",
"devoted",
"devotional",
"devouring",
"devout",
"deweyan",
"dewy",
"dexter",
"dexterous",
"dextral",
"dextrorotary",
"dextrorotatory",
"dextrorsal",
"dextrorse",
"dextrous",
"diabatic",
"diabetic",
"diabolic",
"diabolical",
"diachronic",
"diacritic",
"diacritical",
"diadromous",
"diagnosable",
"diagnostic",
"diagonal",
"diagonalizable",
"diagrammatic",
"diagrammatical",
"dialectal",
"dialectic",
"dialectical",
"diamagnetic",
"diamantine",
"diametral",
"diametric",
"diametrical",
"dianoetic",
"diaphanous",
"diaphoretic",
"diaphyseal",
"diaphysial",
"diarrheal",
"diarrheic",
"diarrhetic",
"diarrhoeal",
"diarrhoeic",
"diarrhoetic",
"diastolic",
"diatomic",
"diatonic",
"diazo",
"dicarboxylic",
"dicey",
"dichotomous",
"dichromatic",
"dickensian",
"dickey",
"dicky",
"diclinous",
"dicotyledonous",
"dictated",
"dictatorial",
"dictyopteran",
"didactic",
"didactical",
"diestrous",
"diestrual",
"dietary",
"dietetic",
"dietetical",
"different",
"differentiable",
"differential",
"differentiated",
"difficult",
"diffident",
"diffuse",
"diffused",
"diffusing",
"diffusive",
"digestible",
"digestive",
"dighted",
"digital",
"digitate",
"digitigrade",
"dignified",
"dignifying",
"digressive",
"dilapidated",
"dilatory",
"dilettante",
"dilettanteish",
"dilettantish",
"diligent",
"dilute",
"diluted",
"diluvial",
"diluvian",
"dimensional",
"dimensioning",
"diminished",
"diminishing",
"diminuendo",
"diminutive",
"dimmed",
"dimorphic",
"dimorphous",
"dingy",
"dinky",
"diocesan",
"dioecian",
"dioecious",
"dioestrous",
"dioestrual",
"dionysian",
"diploid",
"diplomatic",
"diplomatical",
"dipolar",
"dipped",
"dipterous",
"dipylon",
"dire",
"direct",
"directed",
"directing",
"directional",
"directionless",
"directive",
"direful",
"dirigible",
"dirt",
"dirty",
"disabled",
"disabling",
"disabused",
"disadvantaged",
"disadvantageous",
"disaffected",
"disagreeable",
"disappointed",
"disappointing",
"disapproving",
"disarming",
"disarranged",
"disarrayed",
"disastrous",
"disavowable",
"disbelieving",
"discalceate",
"discalced",
"discarded",
"discernable",
"discernible",
"discerning",
"discharged",
"disciform",
"disciplinal",
"disciplinary",
"disciplined",
"disclike",
"disclosed",
"discoid",
"discoidal",
"discombobulated",
"discomfited",
"discomposed",
"discomycetous",
"disconcerted",
"disconcerting",
"disconfirming",
"disconnected",
"disconsolate",
"discontent",
"discontented",
"discontinued",
"discontinuous",
"discordant",
"discorporate",
"discouraged",
"discouraging",
"discourteous",
"discoverable",
"discovered",
"discreditable",
"discredited",
"discreet",
"discrepant",
"discrete",
"discretional",
"discretionary",
"discriminable",
"discriminate",
"discriminating",
"discriminative",
"discriminatory",
"discursive",
"disdainful",
"diseased",
"disembodied",
"disenchanted",
"disenchanting",
"disenfranchised",
"disentangled",
"disfigured",
"disfranchised",
"disgraced",
"disgraceful",
"disgruntled",
"disguised",
"disgusted",
"disgustful",
"disgusting",
"disharmonious",
"disheartened",
"disheartening",
"dished",
"disheveled",
"dishevelled",
"dishonest",
"dishonorable",
"dishonored",
"dishonourable",
"dishy",
"disillusioned",
"disillusioning",
"disinclined",
"disinfectant",
"disingenuous",
"disinherited",
"disintegrable",
"disintegrative",
"disinterested",
"disjoined",
"disjoint",
"disjointed",
"disjunct",
"disjunctive",
"disklike",
"dislikable",
"disliked",
"dislocated",
"dislogistic",
"disloyal",
"dismal",
"dismantled",
"dismayed",
"dismaying",
"dismissed",
"dismissible",
"dismissive",
"disobedient",
"disobliging",
"disordered",
"disorderly",
"disorganised",
"disorganized",
"disoriented",
"disorienting",
"disparaging",
"disparate",
"dispassionate",
"dispensable",
"dispensed",
"dispersed",
"dispersive",
"dispirited",
"dispiriting",
"displeased",
"displeasing",
"disposable",
"disposed",
"dispossessed",
"disproportional",
"disputable",
"disputatious",
"disputative",
"disputed",
"disqualified",
"disqualifying",
"disquieted",
"disquieting",
"disregarded",
"disreputable",
"disrespectful",
"disrupted",
"disruptive",
"dissatisfactory",
"dissatisfied",
"dissected",
"disseminative",
"dissentient",
"dissenting",
"dissentious",
"dissident",
"dissilient",
"dissimilar",
"dissimulative",
"dissipated",
"dissociable",
"dissociative",
"dissoluble",
"dissolute",
"dissolvable",
"dissolved",
"dissonant",
"dissuasive",
"distaff",
"distal",
"distant",
"distasteful",
"distensible",
"distinct",
"distinctive",
"distinguishable",
"distinguished",
"distortable",
"distorted",
"distracted",
"distrait",
"distraught",
"distressed",
"distressful",
"distressing",
"distributed",
"distributional",
"distributive",
"distrustful",
"disturbed",
"disturbing",
"disunited",
"disused",
"disyllabic",
"dithyrambic",
"diurnal",
"divalent",
"divergent",
"diverging",
"divers",
"diverse",
"diversified",
"diversionary",
"diverted",
"diverting",
"dividable",
"divided",
"divinatory",
"divine",
"divisible",
"divisional",
"divisive",
"divorced",
"dizygotic",
"dizygous",
"dizzy",
"djiboutian",
"doable",
"docile",
"doctoral",
"doctorial",
"doctrinaire",
"doctrinal",
"documental",
"documentary",
"documented",
"doddering",
"doddery",
"dodgy",
"dogged",
"dogging",
"doglike",
"dogmatic",
"dogmatical",
"dolabrate",
"dolabriform",
"doleful",
"dolichocephalic",
"dolichocranial",
"dolichocranic",
"dolomitic",
"dolorous",
"dolourous",
"doltish",
"domed",
"domestic",
"domesticated",
"domiciliary",
"dominant",
"dominated",
"dominating",
"domineering",
"dominical",
"dominican",
"donatist",
"done",
"donnean",
"donnian",
"donnish",
"doomed",
"doped",
"dopey",
"dopy",
"dorian",
"doric",
"dormant",
"dormie",
"dormy",
"dorsal",
"dorsoventral",
"dosed",
"dostoevskian",
"dostoyevskian",
"doting",
"dotted",
"dotty",
"double",
"doubled",
"doubtful",
"doubting",
"doughy",
"dour",
"dovish",
"dowdy",
"dowered",
"dowerless",
"down",
"downbound",
"downcast",
"downfield",
"downhearted",
"downhill",
"downlike",
"downmarket",
"downright",
"downscale",
"downstage",
"downstair",
"downstairs",
"downstream",
"downtown",
"downtrodden",
"downward",
"downwind",
"downy",
"dozen",
"dozy",
"drab",
"draconian",
"drafty",
"dragging",
"draggled",
"drained",
"draining",
"dramatic",
"dramaturgic",
"dramaturgical",
"draped",
"drastic",
"draughty",
"drawn",
"dread",
"dreaded",
"dreadful",
"dreamed",
"dreamless",
"dreamlike",
"dreamy",
"drear",
"dreary",
"drenched",
"dress",
"dressed",
"dressy",
"dried",
"drifting",
"drilled",
"drinkable",
"dripless",
"drippy",
"driven",
"driving",
"drizzling",
"drizzly",
"droll",
"drooping",
"droopy",
"dropping",
"dropsical",
"drowsing",
"drowsy",
"drudging",
"drugged",
"drugless",
"drumhead",
"drunk",
"drunken",
"drupaceous",
"dual",
"dualistic",
"dubious",
"dubitable",
"ducal",
"duckbill",
"ductile",
"ductless",
"dulcet",
"dull",
"dulled",
"dumb",
"dumbfounded",
"dumbfounding",
"dumbstricken",
"dumbstruck",
"dumfounded",
"dumfounding",
"dummy",
"dumpy",
"duncical",
"duncish",
"duodecimal",
"duodenal",
"duple",
"duplex",
"duplicable",
"duplicatable",
"duplicate",
"duplicitous",
"durable",
"dural",
"dusky",
"dustlike",
"dusty",
"dutch",
"duteous",
"dutiable",
"dutiful",
"dwarfish",
"dwindling",
"dyadic",
"dyed",
"dying",
"dynamic",
"dynamical",
"dynastic",
"dysfunctional",
"dysgenic",
"dyslectic",
"dyslexic",
"dyslogistic",
"dyspeptic",
"dysphemistic",
"dysphoric",
"dysplastic",
"dyspneal",
"dyspneic",
"dyspnoeal",
"dyspnoeic",
"dystopian",
"each",
"eager",
"eared",
"earless",
"earlier",
"earliest",
"early",
"earlyish",
"earned",
"earnest",
"earsplitting",
"earthborn",
"earthbound",
"earthen",
"earthlike",
"earthly",
"earthshaking",
"earthy",
"eased",
"east",
"eastbound",
"easterly",
"eastern",
"easternmost",
"eastmost",
"eastside",
"eastward",
"easy",
"easygoing",
"eatable",
"ebionite",
"ebon",
"ebony",
"ebracteate",
"ebullient",
"eccentric",
"ecclesiastic",
"ecclesiastical",
"eccrine",
"ecdemic",
"echoic",
"echoing",
"echoless",
"echolike",
"echt",
"eclectic",
"ecologic",
"ecological",
"econometric",
"economic",
"economical",
"ecstatic",
"ectodermal",
"ectodermic",
"ectomorphic",
"ectopic",
"ectothermic",
"ectozoan",
"ecuadorian",
"ecumenic",
"ecumenical",
"edacious",
"edematous",
"edental",
"edentate",
"edentulate",
"edentulous",
"edged",
"edgeless",
"edgy",
"edible",
"edified",
"edifying",
"edited",
"editorial",
"educated",
"educational",
"educative",
"edwardian",
"eellike",
"eerie",
"eery",
"effaceable",
"effected",
"effective",
"effectual",
"effeminate",
"efferent",
"effervescent",
"effervescing",
"effete",
"efficacious",
"efficient",
"efflorescent",
"effluent",
"effortful",
"effortless",
"effulgent",
"effusive",
"egalitarian",
"egocentric",
"egoistic",
"egoistical",
"egotistic",
"egotistical",
"egregious",
"egyptian",
"eidetic",
"eight",
"eighteen",
"eighteenth",
"eightfold",
"eighth",
"eightieth",
"eightpenny",
"eighty",
"einsteinian",
"elaborate",
"elaborated",
"elapsed",
"elastic",
"elasticised",
"elasticized",
"elated",
"elating",
"elder",
"elderly",
"eldest",
"eldritch",
"elect",
"elected",
"elective",
"electoral",
"electric",
"electrical",
"electrifying",
"electrochemical",
"electrolytic",
"electromagnetic",
"electromotive",
"electronegative",
"electroneutral",
"electronic",
"electrophoretic",
"electropositive",
"electrostatic",
"eleemosynary",
"elegant",
"elegiac",
"elemental",
"elementary",
"elephantine",
"elevated",
"eleven",
"eleventh",
"elfin",
"elfish",
"elflike",
"elicited",
"eligible",
"elite",
"elizabethan",
"ellipsoid",
"ellipsoidal",
"elliptic",
"elliptical",
"elocutionary",
"elongate",
"elongated",
"eloquent",
"elucidative",
"elusive",
"elvish",
"elysian",
"emaciated",
"emancipated",
"emancipative",
"emarginate",
"emasculate",
"emasculated",
"embarrassed",
"embarrassing",
"embattled",
"embedded",
"embezzled",
"emblematic",
"emblematical",
"embodied",
"emboldened",
"embolic",
"embonpoint",
"embossed",
"embroiled",
"embryologic",
"embryonal",
"embryonic",
"embryotic",
"emended",
"emergent",
"emerging",
"emeritus",
"eminent",
"emmetropic",
"emollient",
"emotional",
"emotionless",
"emotive",
"empathetic",
"empathic",
"emphasised",
"emphasized",
"emphatic",
"emphysematous",
"empiric",
"empirical",
"employable",
"employed",
"empowered",
"empty",
"empurpled",
"empyreal",
"empyrean",
"emulous",
"enabling",
"enamored",
"enate",
"enatic",
"encased",
"enceinte",
"enchained",
"enchanted",
"enchanting",
"encircled",
"encircling",
"enclosed",
"encomiastic",
"encompassing",
"encouraged",
"encouraging",
"encroaching",
"encrusted",
"encumbered",
"encyclical",
"encyclopaedic",
"encyclopedic",
"encysted",
"endangered",
"endearing",
"ended",
"endemic",
"endemical",
"endergonic",
"endermatic",
"endermic",
"endless",
"endocentric",
"endocrinal",
"endocrine",
"endodontic",
"endoergic",
"endogamic",
"endogamous",
"endogenetic",
"endogenic",
"endogenous",
"endometrial",
"endomorphic",
"endoparasitic",
"endoscopic",
"endothelial",
"endothermal",
"endothermic",
"endovenous",
"endowed",
"endozoan",
"endozoic",
"endurable",
"enduring",
"energetic",
"energising",
"energizing",
"enervated",
"enervating",
"enfeebling",
"enforceable",
"enforced",
"enfranchised",
"engaged",
"engaging",
"english",
"engorged",
"engraved",
"engrossed",
"engrossing",
"enhanced",
"enhancive",
"enigmatic",
"enigmatical",
"enjoyable",
"enkindled",
"enlarged",
"enlightened",
"enlightening",
"enlivened",
"enlivening",
"enmeshed",
"ennobling",
"enolic",
"enormous",
"enough",
"enraged",
"enraptured",
"ensiform",
"ensorcelled",
"ensuant",
"ensuing",
"entangled",
"enteral",
"enteric",
"enterprising",
"entertained",
"entertaining",
"enthralled",
"enthralling",
"enthusiastic",
"enticing",
"entire",
"entitled",
"entomologic",
"entomological",
"entomophilous",
"entozoan",
"entozoic",
"entranced",
"entrancing",
"entrenched",
"entrepreneurial",
"enumerable",
"enured",
"enveloping",
"enviable",
"envious",
"environmental",
"envisioned",
"enwrapped",
"enzootic",
"enzymatic",
"eolithic",
"eolotropic",
"eonian",
"eosinophilic",
"eparchial",
"epenthetic",
"ephemeral",
"ephesian",
"epic",
"epical",
"epicanthic",
"epicarpal",
"epicene",
"epicurean",
"epicyclic",
"epicyclical",
"epideictic",
"epideictical",
"epidemic",
"epidemiologic",
"epidemiological",
"epidermal",
"epidermic",
"epidural",
"epigastric",
"epigrammatic",
"epileptic",
"epilithic",
"epimorphic",
"epiphyseal",
"epiphysial",
"epiphytic",
"epiphytotic",
"episcopal",
"episcopalian",
"episodic",
"epistemic",
"epistemological",
"epistolary",
"epistolatory",
"epithelial",
"epitheliod",
"epizoan",
"epizoic",
"epizootic",
"epochal",
"eponymic",
"eponymous",
"equable",
"equal",
"equanimous",
"equatorial",
"equestrian",
"equiangular",
"equidistant",
"equilateral",
"equine",
"equinoctial",
"equipoised",
"equipotent",
"equipped",
"equiprobable",
"equipt",
"equitable",
"equivalent",
"equivocal",
"eradicable",
"erasable",
"erasmian",
"erect",
"erectile",
"eremitic",
"eremitical",
"ergodic",
"ergonomic",
"ergotic",
"ergotropic",
"eristic",
"eristical",
"eritrean",
"eroded",
"erogenous",
"erose",
"erosive",
"erotic",
"errant",
"erratic",
"errhine",
"erring",
"erroneous",
"errorless",
"ersatz",
"erstwhile",
"erudite",
"eruptive",
"erythematous",
"erythroid",
"erythropoietic",
"escaped",
"eschatological",
"esophageal",
"esoteric",
"especial",
"essene",
"essential",
"established",
"esteemed",
"esthetic",
"esthetical",
"estimable",
"estival",
"estonian",
"estranged",
"estranging",
"estrogenic",
"estrous",
"estuarial",
"estuarine",
"esurient",
"etched",
"eternal",
"ethereal",
"ethical",
"ethiopian",
"ethnic",
"ethnical",
"ethnocentric",
"ethnographic",
"ethnographical",
"ethnologic",
"ethnological",
"etiolate",
"etiolated",
"etiologic",
"etiological",
"etymological",
"eucaryotic",
"eucharistic",
"euclidean",
"euclidian",
"eudaemonic",
"eudemonic",
"eugenic",
"eukaryotic",
"eulogistic",
"euphemistic",
"euphonic",
"euphonical",
"euphonious",
"euphonous",
"euphoriant",
"euphoric",
"eupneic",
"eupnoeic",
"eurafrican",
"eurasian",
"eurasiatic",
"eurocentric",
"european",
"europocentric",
"eusporangiate",
"eutherian",
"eutrophic",
"evacuant",
"evaluative",
"evanescent",
"evangelical",
"evangelistic",
"evaporable",
"evaporated",
"evaporative",
"evasive",
"even",
"evenhanded",
"eventful",
"eventual",
"evergreen",
"everlasting",
"every",
"everyday",
"evidenced",
"evident",
"evidential",
"evidentiary",
"evil",
"eviscerate",
"evitable",
"evocative",
"evoked",
"evolutionary",
"exacerbating",
"exact",
"exacting",
"exaggerated",
"exalted",
"exalting",
"exanimate",
"exasperated",
"exasperating",
"exaugural",
"exceeding",
"excellent",
"exceptionable",
"exceptional",
"excess",
"excessive",
"exchangeable",
"exchanged",
"excitable",
"excitant",
"excitative",
"excitatory",
"excited",
"exciting",
"exclamatory",
"exclusive",
"excogitative",
"excrescent",
"excretory",
"excruciating",
"exculpated",
"exculpatory",
"excursive",
"excusable",
"excusatory",
"excused",
"execrable",
"executable",
"executed",
"executive",
"exegetic",
"exegetical",
"exemplary",
"exemplifying",
"exempt",
"exergonic",
"exhausted",
"exhaustible",
"exhausting",
"exhaustive",
"exhibitionistic",
"exhilarated",
"exhilarating",
"exhortative",
"exhortatory",
"exigent",
"exiguous",
"exilic",
"existent",
"existential",
"existentialist",
"existing",
"exocentric",
"exocrine",
"exodontic",
"exoergic",
"exogamic",
"exogamous",
"exogenic",
"exogenous",
"exonerated",
"exonerative",
"exorbitant",
"exoteric",
"exothermal",
"exothermic",
"exotic",
"expandable",
"expanded",
"expandible",
"expansible",
"expansile",
"expansionist",
"expansive",
"expectable",
"expectant",
"expected",
"expedient",
"expeditionary",
"expeditious",
"expendable",
"expensive",
"experienced",
"experient",
"experiential",
"experimental",
"expert",
"expiable",
"expiative",
"expiatory",
"expiratory",
"expired",
"explainable",
"explanatory",
"explicable",
"explicit",
"exploded",
"exploitative",
"exploitatory",
"exploited",
"exploitive",
"explorative",
"exploratory",
"explosive",
"exponential",
"exportable",
"exposed",
"expositive",
"expository",
"express",
"expressed",
"expressible",
"expressionist",
"expressionistic",
"expressionless",
"expressive",
"expurgated",
"exquisite",
"exsanguine",
"exsanguinous",
"extant",
"extemporaneous",
"extemporary",
"extempore",
"extendable",
"extended",
"extendible",
"extensible",
"extensile",
"extensional",
"extensive",
"extenuating",
"exterior",
"exterminable",
"exterminated",
"external",
"exteroceptive",
"exterritorial",
"extinct",
"extinguishable",
"extinguished",
"extirpable",
"extortionate",
"extra",
"extracellular",
"extractable",
"extractible",
"extracurricular",
"extradural",
"extragalactic",
"extrajudicial",
"extralegal",
"extralinguistic",
"extramarital",
"extramural",
"extraneous",
"extraordinaire",
"extraordinary",
"extrasensory",
"extrasystolic",
"extravagant",
"extraversive",
"extravert",
"extraverted",
"extravertive",
"extreme",
"extremist",
"extricable",
"extrinsic",
"extropic",
"extrospective",
"extroversive",
"extrovert",
"extroverted",
"extrovertish",
"extrovertive",
"extrusive",
"exuberant",
"exultant",
"exulting",
"exuvial",
"eyed",
"eyeless",
"eyelike",
"fabian",
"fabled",
"fabricated",
"fabulous",
"faced",
"faceless",
"faceted",
"facetious",
"facial",
"facile",
"facilitative",
"facilitatory",
"factious",
"factitious",
"factorial",
"factual",
"facultative",
"faddish",
"faddy",
"faded",
"faecal",
"fagged",
"fahrenheit",
"failing",
"fain",
"faineant",
"faint",
"fainthearted",
"fair",
"fairish",
"faithful",
"faithless",
"fake",
"falcate",
"falciform",
"falconine",
"fallacious",
"fallen",
"fallible",
"falling",
"fallow",
"false",
"falsetto",
"falsifiable",
"falstaffian",
"faltering",
"famed",
"familial",
"familiar",
"familiarised",
"familiarising",
"familiarized",
"familiarizing",
"famished",
"famous",
"fanatic",
"fanatical",
"fancied",
"fanciful",
"fancy",
"fanged",
"fanlike",
"fanned",
"fantabulous",
"fantastic",
"fantastical",
"faraway",
"farcical",
"farfetched",
"farinaceous",
"farming",
"farseeing",
"farsighted",
"farther",
"farthermost",
"farthest",
"fascinated",
"fascinating",
"fascist",
"fascistic",
"fashionable",
"fashioned",
"fast",
"fastened",
"fastidious",
"fastigiate",
"fatal",
"fatalist",
"fatalistic",
"fated",
"fateful",
"fatheaded",
"fatherless",
"fatherlike",
"fatherly",
"fathomable",
"fatigued",
"fatless",
"fattened",
"fattening",
"fattish",
"fatty",
"fatuous",
"faucal",
"faultfinding",
"faultless",
"faulty",
"faustian",
"faux",
"faveolate",
"favorable",
"favored",
"favorite",
"favourable",
"favourite",
"fawning",
"fazed",
"fearful",
"fearless",
"fearsome",
"feasible",
"featherbrained",
"feathered",
"featheredged",
"featherless",
"featherlike",
"feathery",
"featured",
"featureless",
"febrile",
"fecal",
"feckless",
"feculent",
"fecund",
"federal",
"federate",
"federated",
"feeble",
"feebleminded",
"feigned",
"feisty",
"felicitous",
"feline",
"fell",
"felonious",
"felted",
"female",
"feminine",
"feminist",
"femoral",
"fencelike",
"fenestral",
"feral",
"ferial",
"ferine",
"fermentable",
"ferned",
"fernless",
"fernlike",
"ferny",
"ferocious",
"ferric",
"ferromagnetic",
"ferrous",
"fertile",
"fertilizable",
"fervent",
"fervid",
"festal",
"festive",
"fetal",
"fetching",
"fetid",
"fettered",
"feudal",
"feudalistic",
"feudatory",
"fevered",
"feverish",
"feverous",
"fewer",
"fewest",
"fiberoptic",
"fibreoptic",
"fibrillose",
"fibrinous",
"fibrocalcific",
"fibrous",
"fickle",
"fictile",
"fictional",
"fictitious",
"fictive",
"fiddling",
"fidgety",
"fiducial",
"fiduciary",
"fiendish",
"fierce",
"fiery",
"fifteen",
"fifteenth",
"fifth",
"fiftieth",
"fifty",
"fighting",
"figural",
"figurative",
"figured",
"fijian",
"filamentlike",
"filamentous",
"filar",
"filarial",
"filariid",
"filial",
"filiform",
"filipino",
"filled",
"filmable",
"filmed",
"filmy",
"filthy",
"fimbriate",
"finable",
"final",
"financial",
"fine",
"fineable",
"finer",
"finespun",
"fingered",
"fingerless",
"fingerlike",
"finical",
"finicky",
"finished",
"finite",
"finnish",
"fired",
"fireproof",
"firm",
"firmamental",
"first",
"firstborn",
"firsthand",
"fiscal",
"fisheye",
"fishy",
"fissile",
"fissionable",
"fissiparous",
"fistular",
"fistulate",
"fistulous",
"fitful",
"fitted",
"fitter",
"fitting",
"five",
"fivefold",
"fixed",
"fizzing",
"fizzy",
"flabbergasted",
"flabby",
"flaccid",
"flagellate",
"flagellated",
"flagging",
"flagitious",
"flagrant",
"flakey",
"flaky",
"flamboyant",
"flameproof",
"flaming",
"flammable",
"flaring",
"flash",
"flashy",
"flat",
"flatbottom",
"flatbottomed",
"flatfooted",
"flattened",
"flattering",
"flatulent",
"flaunty",
"flavorful",
"flavorless",
"flavorous",
"flavorsome",
"flavourful",
"flavourless",
"flavourous",
"flavoursome",
"flawed",
"flawless",
"flaxen",
"flecked",
"fledged",
"fledgeless",
"fledgeling",
"fledgling",
"fleeceable",
"fleecy",
"fleet",
"fleeting",
"flemish",
"fleshly",
"fleshy",
"flexible",
"flexile",
"flexuous",
"flickering",
"flighted",
"flightless",
"flighty",
"flimsy",
"flint",
"flinty",
"flip",
"flippant",
"flirtatious",
"floating",
"floaty",
"floccose",
"flocculent",
"flooded",
"floodlighted",
"floodlit",
"floored",
"floppy",
"floral",
"florentine",
"floricultural",
"florid",
"flossy",
"flourishing",
"floury",
"flowered",
"flowering",
"flowerless",
"flowery",
"flowing",
"fluctuating",
"fluent",
"fluffy",
"fluid",
"flukey",
"fluky",
"fluorescent",
"flush",
"flushed",
"flustered",
"fluvial",
"flyaway",
"flyblown",
"flying",
"flyspeck",
"foaming",
"foamy",
"focal",
"focused",
"focussed",
"foetal",
"foetid",
"fogbound",
"fogged",
"foggy",
"fogyish",
"foiled",
"foldable",
"foldaway",
"folding",
"foliaceous",
"foliaged",
"foliate",
"foliated",
"foliolate",
"foliose",
"folksy",
"follicular",
"following",
"fond",
"foodless",
"foolhardy",
"fooling",
"foolish",
"foolproof",
"footed",
"footless",
"footling",
"footloose",
"footsore",
"footsure",
"foppish",
"forbearing",
"forbidden",
"forbidding",
"forced",
"forceful",
"forceless",
"forcible",
"forcipate",
"fordable",
"fore",
"foreboding",
"foregoing",
"foregone",
"forehand",
"forehanded",
"foreign",
"foremost",
"forensic",
"foreordained",
"foreseeable",
"foreshadowing",
"foresighted",
"foresightful",
"forested",
"forethoughtful",
"forfeit",
"forfeited",
"forficate",
"forged",
"forgetful",
"forgettable",
"forgivable",
"forgiving",
"forgotten",
"forked",
"forlorn",
"formal",
"formalised",
"formalistic",
"formalized",
"formative",
"formed",
"former",
"formic",
"formidable",
"formless",
"formosan",
"formulaic",
"formulary",
"formulated",
"forte",
"fortemente",
"forthcoming",
"forthright",
"fortieth",
"fortified",
"fortissimo",
"fortnightly",
"fortuitous",
"fortunate",
"forty",
"forward",
"fossil",
"fossiliferous",
"fossilised",
"fossilized",
"fossorial",
"foster",
"foul",
"fouled",
"found",
"four",
"fourfold",
"fourhanded",
"fourpenny",
"fourscore",
"foursquare",
"fourteen",
"fourteenth",
"fourth",
"foxy",
"fractional",
"fractious",
"fragile",
"fragmental",
"fragmentary",
"fragmented",
"fragrant",
"frail",
"framed",
"franciscan",
"frangible",
"frank",
"frankish",
"frantic",
"fraternal",
"fraudulent",
"fraught",
"frayed",
"freakish",
"freaky",
"freckled",
"free",
"freeborn",
"freehand",
"freehanded",
"freehearted",
"freelance",
"freestanding",
"freewheeling",
"freewill",
"french",
"frenetic",
"frenzied",
"frequent",
"fresh",
"freshman",
"fretful",
"fretted",
"freudian",
"friable",
"fricative",
"frictional",
"frictionless",
"fried",
"friendless",
"friendly",
"frightened",
"frightening",
"frightful",
"frigid",
"frigorific",
"frilled",
"frilly",
"fringed",
"fringy",
"frisian",
"frisky",
"frivolous",
"frizzly",
"frizzy",
"frolicky",
"frolicsome",
"front",
"frontal",
"frontmost",
"frore",
"frostbitten",
"frosted",
"frostian",
"frosty",
"frothing",
"frothy",
"froward",
"frowning",
"frowsty",
"frowsy",
"frowzled",
"frowzy",
"frozen",
"frugal",
"fruitful",
"fruiting",
"fruitless",
"fruity",
"frumpish",
"frumpy",
"frustrated",
"frustrating",
"frustrative",
"fruticose",
"fruticulose",
"fucking",
"fuddled",
"fueled",
"fugacious",
"fugal",
"fuggy",
"fugitive",
"fugly",
"fulfilled",
"fulgent",
"fulgid",
"fulgurant",
"fulgurating",
"fulgurous",
"full",
"fulminant",
"fulsome",
"fumbling",
"fumed",
"functional",
"functioning",
"fundamental",
"fundamentalist",
"funded",
"funerary",
"funereal",
"fungal",
"fungible",
"fungicidal",
"fungoid",
"fungous",
"funguslike",
"funicular",
"funky",
"funny",
"furious",
"furled",
"furlike",
"furnished",
"furred",
"furrowed",
"furry",
"further",
"furthermost",
"furthest",
"furtive",
"fuscous",
"fused",
"fusible",
"fusiform",
"fussy",
"fusty",
"futile",
"future",
"futureless",
"futurist",
"futuristic",
"fuzzed",
"fuzzy",
"gabby",
"gabled",
"gabonese",
"gaelic",
"gaga",
"gainful",
"gainly",
"galactic",
"galilaean",
"galilean",
"gallant",
"galled",
"gallic",
"gallican",
"gallinaceous",
"galling",
"galore",
"galvanic",
"galvanising",
"galvanizing",
"galwegian",
"gambian",
"game",
"gamey",
"gammy",
"gamopetalous",
"gamy",
"gandhian",
"gangling",
"gangly",
"gangrenous",
"gaping",
"garbed",
"garbled",
"gardant",
"garden",
"gargantuan",
"garish",
"garlicky",
"garmented",
"garmentless",
"garrulous",
"gaseous",
"gasified",
"gassy",
"gastric",
"gastroduodenal",
"gastronomic",
"gastronomical",
"gathered",
"gauche",
"gaudy",
"gauguinesque",
"gaumless",
"gaunt",
"gauntleted",
"gaussian",
"gauzy",
"gawky",
"geared",
"gelatinlike",
"gelatinous",
"gelded",
"gelid",
"gemmed",
"gemmiferous",
"genealogic",
"genealogical",
"general",
"generalised",
"generalized",
"generational",
"generative",
"generic",
"generous",
"genetic",
"genetical",
"genial",
"genic",
"geniculate",
"genital",
"genitive",
"genitourinary",
"genoese",
"genotypic",
"genotypical",
"genovese",
"genteel",
"gentile",
"gentle",
"gentlemanlike",
"gentlemanly",
"genuine",
"geocentric",
"geodesic",
"geodesical",
"geodetic",
"geographic",
"geographical",
"geologic",
"geological",
"geometric",
"geometrical",
"geomorphologic",
"geophysical",
"geophytic",
"geopolitical",
"georgian",
"geostationary",
"geostrategic",
"geosynchronous",
"geothermal",
"geothermic",
"geriatric",
"german",
"germane",
"germanic",
"germfree",
"germicidal",
"germinal",
"germy",
"gerontological",
"gerundial",
"gestational",
"gesticulating",
"gestural",
"getable",
"getatable",
"gettable",
"ghanaian",
"ghanese",
"ghanian",
"ghastly",
"ghostlike",
"ghostly",
"ghoulish",
"giant",
"gibbose",
"gibbous",
"gibelike",
"gibraltarian",
"giddy",
"gifted",
"gigantic",
"gilbertian",
"gilded",
"gilled",
"gilt",
"gimbaled",
"gimcrack",
"gimpy",
"ginger",
"gingerly",
"gingery",
"gingival",
"girlish",
"given",
"giving",
"glabellar",
"glabrescent",
"glabrous",
"glace",
"glacial",
"glaciated",
"glad",
"gladdened",
"gladiatorial",
"gladsome",
"glamorous",
"glamourous",
"glandular",
"glaring",
"glary",
"glassed",
"glassless",
"glassy",
"glaswegian",
"glaucous",
"glazed",
"gleaming",
"gleeful",
"glial",
"glib",
"glimmery",
"glinting",
"glistening",
"glistering",
"glittering",
"glittery",
"global",
"globose",
"globular",
"glomerular",
"gloomful",
"glooming",
"gloomy",
"glorified",
"glorious",
"glossy",
"glottal",
"gloved",
"gloveless",
"glowering",
"glowing",
"glued",
"gluey",
"glum",
"gluteal",
"glutinous",
"glutted",
"gluttonous",
"glycogenic",
"gnarled",
"gnarly",
"gnomic",
"gnomish",
"gnostic",
"goaded",
"goalless",
"goateed",
"gobsmacked",
"goddam",
"goddamn",
"goddamned",
"godforsaken",
"godless",
"godlike",
"godly",
"goethean",
"goethian",
"going",
"gold",
"golden",
"gonadal",
"gonadotrophic",
"gonadotropic",
"gone",
"gonzo",
"good",
"goodish",
"goodly",
"gooey",
"goofy",
"gooselike",
"goosey",
"goosy",
"gordian",
"gorgeous",
"gormless",
"gory",
"gossamer",
"gossipy",
"gothic",
"gouty",
"governable",
"governing",
"governmental",
"gowned",
"grabby",
"graceful",
"graceless",
"gracile",
"gracious",
"gradable",
"gradational",
"gradatory",
"graded",
"gradual",
"graduate",
"graduated",
"graecophile",
"graecophilic",
"grainy",
"grammatic",
"grammatical",
"grand",
"grandiloquent",
"grandiose",
"granitelike",
"granitic",
"granted",
"granular",
"granulated",
"granuliferous",
"granulocytic",
"granulomatous",
"granulose",
"grapelike",
"grapey",
"graphic",
"graphical",
"grapy",
"graspable",
"grasping",
"grassless",
"grasslike",
"grassroots",
"grassy",
"grateful",
"gratified",
"gratifying",
"grating",
"gratis",
"gratuitous",
"gratulatory",
"grave",
"gravelly",
"graven",
"gravid",
"gravimetric",
"gravitational",
"gravitative",
"gray",
"grayish",
"grazed",
"greased",
"greaseproof",
"greasy",
"great",
"greater",
"greatest",
"greathearted",
"grecian",
"greedy",
"greek",
"green",
"greenhouse",
"greenish",
"greensick",
"greenside",
"gregarious",
"gregorian",
"grenadian",
"grey",
"greyed",
"greyish",
"grieving",
"grievous",
"grilled",
"grim",
"grimy",
"gripping",
"grisly",
"gristly",
"gritty",
"grizzled",
"grizzly",
"groggy",
"groomed",
"grooved",
"groovy",
"groping",
"gross",
"grotesque",
"grotty",
"grouchy",
"groundbreaking",
"groundless",
"grouped",
"groveling",
"grovelling",
"growing",
"grown",
"grownup",
"grubby",
"grudging",
"grueling",
"gruelling",
"gruesome",
"gruff",
"grumbling",
"grumose",
"grumous",
"grumpy",
"grungy",
"guardant",
"guarded",
"guatemalan",
"gubernatorial",
"guided",
"guiding",
"guileful",
"guileless",
"guiltless",
"guilty",
"guinean",
"gullible",
"gummed",
"gummy",
"gumptious",
"gushing",
"gushy",
"gusseted",
"gustative",
"gustatorial",
"gustatory",
"gusty",
"gutless",
"gutsy",
"guttural",
"guyanese",
"gymnastic",
"gymnosophical",
"gymnospermous",
"gynaecological",
"gynandromorphic",
"gynecologic",
"gynecological",
"gyral",
"gyroscopic",
"habilimented",
"habitable",
"habited",
"habitual",
"hackneyed",
"hadal",
"hadean",
"haemal",
"haematal",
"haematic",
"haematogenic",
"haematological",
"haematopoietic",
"haemic",
"haemolytic",
"haemophilic",
"haemopoietic",
"haemorrhagic",
"haggard",
"hagridden",
"haired",
"hairless",
"hairlike",
"hairsplitting",
"hairy",
"haitian",
"halal",
"halcyon",
"hale",
"half",
"halfhearted",
"halfway",
"hallowed",
"hallucinating",
"hallucinatory",
"hallucinogenic",
"halt",
"halting",
"hammered",
"hammy",
"handed",
"handelian",
"handheld",
"handicapped",
"handled",
"handleless",
"handless",
"handmade",
"handsewn",
"handsome",
"handstitched",
"handwoven",
"handwritten",
"handy",
"hangdog",
"hanoverian",
"haphazard",
"hapless",
"haploid",
"haploidic",
"happy",
"haptic",
"harassed",
"hard",
"hardback",
"hardbacked",
"hardbound",
"hardcore",
"hardcover",
"hardened",
"hardfisted",
"hardheaded",
"hardhearted",
"hardline",
"hardscrabble",
"hardworking",
"hardy",
"harebrained",
"harmful",
"harmless",
"harmonic",
"harmonical",
"harmonious",
"harmonised",
"harmonizable",
"harmonized",
"harnessed",
"harried",
"harrowing",
"harsh",
"hasidic",
"hassidic",
"hastate",
"hasty",
"hatched",
"hated",
"hateful",
"hatless",
"hatted",
"haughty",
"haunted",
"haunting",
"hawaiian",
"hawkish",
"haywire",
"hazardous",
"hazel",
"hazy",
"headed",
"headfirst",
"headless",
"headlike",
"headlong",
"headstrong",
"heady",
"healed",
"healing",
"healthful",
"healthier",
"healthy",
"hearable",
"heard",
"hearing",
"hearsay",
"heartbreaking",
"heartbroken",
"heartening",
"heartfelt",
"heartless",
"heartrending",
"heartsick",
"heartwarming",
"hearty",
"heatable",
"heated",
"heathen",
"heathenish",
"heathlike",
"heatless",
"heavenly",
"heavenward",
"heavy",
"heavyhearted",
"heavyset",
"hebdomadal",
"hebdomadary",
"hebephrenic",
"hebraic",
"hebraical",
"hebrew",
"hebridean",
"hectic",
"hedged",
"hedonic",
"hedonistic",
"heedful",
"heedless",
"hefty",
"hegelian",
"heightening",
"heinous",
"held",
"heliac",
"heliacal",
"helical",
"heliocentric",
"hellenic",
"hellenistic",
"hellenistical",
"hellish",
"helmeted",
"helminthic",
"helpful",
"helpless",
"hemal",
"hematal",
"hematic",
"hematogenic",
"hematologic",
"hematological",
"hematopoietic",
"hemic",
"hemimetabolic",
"hemimetabolous",
"hemimetamorphic",
"hemingwayesque",
"hemiparasitic",
"hemispheric",
"hemispherical",
"hemodynamic",
"hemolytic",
"hemophilic",
"hemopoietic",
"hemorrhagic",
"hemostatic",
"hempen",
"henpecked",
"hepatic",
"hepatotoxic",
"heralded",
"heraldic",
"heraldist",
"herbaceous",
"herbal",
"herbivorous",
"herculean",
"here",
"hereditary",
"heretical",
"heritable",
"hermaphrodite",
"hermaphroditic",
"hermeneutic",
"hermetic",
"hermitic",
"hermitical",
"heroic",
"heroical",
"hertzian",
"hesitant",
"hesitating",
"hesperian",
"heterocercal",
"heterocyclic",
"heterodactyl",
"heterodox",
"heterodyne",
"heteroecious",
"heterogeneous",
"heterogenous",
"heteroicous",
"heterologic",
"heterological",
"heterologous",
"heterometabolic",
"heterosexual",
"heterosporous",
"heterothermic",
"heterotrophic",
"heterozygous",
"heuristic",
"hewn",
"hexadecimal",
"hexagonal",
"hexangular",
"hexed",
"hibernal",
"hibernating",
"hick",
"hidden",
"hidebound",
"hideous",
"hidrotic",
"hiemal",
"hierarchal",
"hierarchic",
"hierarchical",
"hieratic",
"hieratical",
"hieroglyphic",
"hieroglyphical",
"hifalutin",
"high",
"highborn",
"highbrow",
"highbrowed",
"higher",
"highfalutin",
"highfaluting",
"highflying",
"highland",
"hilar",
"hilarious",
"hilly",
"himalayan",
"hind",
"hinder",
"hindering",
"hindermost",
"hindi",
"hindmost",
"hindoo",
"hindu",
"hindustani",
"hiplength",
"hipless",
"hipped",
"hippocratic",
"hircine",
"hired",
"hirsute",
"hispanic",
"hispaniolan",
"hispid",
"histologic",
"histological",
"historic",
"historical",
"historied",
"histrionic",
"hitlerian",
"hitless",
"hittite",
"hmong",
"hoar",
"hoarse",
"hoary",
"hobnailed",
"hogged",
"hoggish",
"hokey",
"holey",
"holistic",
"hollow",
"hollywood",
"holographic",
"holographical",
"holometabolic",
"holometabolous",
"holophytic",
"holozoic",
"holy",
"home",
"homebound",
"homegrown",
"homeless",
"homelike",
"homely",
"homemade",
"homeopathic",
"homeostatic",
"homeothermic",
"homeric",
"homesick",
"homespun",
"homeward",
"homey",
"homicidal",
"homiletic",
"homiletical",
"hominal",
"homing",
"hominian",
"hominid",
"hominine",
"homocentric",
"homocercal",
"homochromatic",
"homocyclic",
"homoecious",
"homoerotic",
"homogeneous",
"homogenised",
"homogenized",
"homogenous",
"homoiothermic",
"homologic",
"homological",
"homologous",
"homonymic",
"homonymous",
"homophile",
"homophobic",
"homophonic",
"homophonous",
"homosexual",
"homosporous",
"homostyled",
"homostylic",
"homostylous",
"homothermic",
"homozygous",
"homy",
"honduran",
"honest",
"honey",
"honeycombed",
"honeyed",
"honeylike",
"honied",
"honorable",
"honorary",
"honored",
"honorific",
"honourable",
"hoofed",
"hooflike",
"hooked",
"hooklike",
"hooved",
"hopeful",
"hopeless",
"horary",
"horizontal",
"hormonal",
"horned",
"hornless",
"hornlike",
"horny",
"horrendous",
"horrible",
"horrid",
"horrific",
"horrified",
"horrifying",
"hortative",
"hortatory",
"horticultural",
"hospitable",
"hostile",
"hotheaded",
"hottish",
"hourlong",
"hourly",
"housebound",
"housebroken",
"housewifely",
"howling",
"hoydenish",
"huddled",
"hueless",
"huffish",
"huffy",
"huge",
"hugoesque",
"hulking",
"hulky",
"human",
"humane",
"humanist",
"humanistic",
"humanitarian",
"humanlike",
"humble",
"humbled",
"humbling",
"humdrum",
"humic",
"humid",
"humified",
"humiliated",
"humiliating",
"humongous",
"humoral",
"humorless",
"humorous",
"humourless",
"humourous",
"humpbacked",
"humped",
"hunchbacked",
"hunched",
"hundred",
"hundredth",
"hungarian",
"hungry",
"hunted",
"hurried",
"hurrying",
"hurt",
"hurtful",
"husbandly",
"hushed",
"husky",
"huxleian",
"huxleyan",
"hyaline",
"hyaloid",
"hyaloplasmic",
"hybrid",
"hydrated",
"hydraulic",
"hydric",
"hydrocephalic",
"hydrodynamic",
"hydroelectric",
"hydrographic",
"hydrographical",
"hydrokinetic",
"hydrolyzable",
"hydrometric",
"hydropathic",
"hydrophilic",
"hydrophobic",
"hydrophytic",
"hydroponic",
"hydrostatic",
"hydrous",
"hydroxy",
"hygienic",
"hygienical",
"hygrophytic",
"hygroscopic",
"hymenal",
"hymeneal",
"hymenopterous",
"hyoid",
"hypaethral",
"hyperactive",
"hyperbolic",
"hyperboloidal",
"hypercatalectic",
"hypercritical",
"hyperemic",
"hyperfine",
"hypermetropic",
"hyperopic",
"hypersensitised",
"hypersensitive",
"hypersensitized",
"hypertensive",
"hyperthermal",
"hypertonic",
"hypertrophied",
"hypethral",
"hypnagogic",
"hypnogogic",
"hypnoid",
"hypnotic",
"hypnotised",
"hypnotized",
"hypoactive",
"hypochondriac",
"hypochondriacal",
"hypocritical",
"hypodermal",
"hypodermic",
"hypoglycaemic",
"hypoglycemic",
"hypognathous",
"hypophyseal",
"hypophysial",
"hypotensive",
"hypothalamic",
"hypothermic",
"hypothetic",
"hypothetical",
"hypotonic",
"hypovolaemic",
"hypovolemic",
"hysteric",
"hysterical",
"iambic",
"iatrogenic",
"iberian",
"ibsenian",
"icebound",
"icelandic",
"ichorous",
"icky",
"iconic",
"iconoclastic",
"icosahedral",
"ictal",
"icteric",
"icterogenic",
"ictic",
"ideal",
"idealised",
"idealistic",
"idealized",
"ideational",
"idempotent",
"identical",
"identifiable",
"identified",
"ideographic",
"ideologic",
"ideological",
"idiographic",
"idiomatic",
"idiomatical",
"idiopathic",
"idiosyncratic",
"idiotic",
"idle",
"idolatrous",
"idolised",
"idolized",
"idyllic",
"iffy",
"igneous",
"ignescent",
"ignitable",
"ignited",
"ignitible",
"ignoble",
"ignominious",
"ignorant",
"ignored",
"iliac",
"illative",
"illegal",
"illegible",
"illegitimate",
"illiberal",
"illicit",
"illimitable",
"illiterate",
"illogical",
"illuminated",
"illuminating",
"illusional",
"illusionary",
"illusive",
"illusory",
"illustrative",
"illustrious",
"ilxx",
"ilxxx",
"imaginable",
"imaginary",
"imaginative",
"imbalanced",
"imbecile",
"imbecilic",
"imbricate",
"imbricated",
"imitation",
"imitative",
"immaculate",
"immanent",
"immaterial",
"immature",
"immeasurable",
"immediate",
"immemorial",
"immense",
"immensurable",
"imminent",
"immiscible",
"immobile",
"immoderate",
"immodest",
"immoral",
"immortal",
"immotile",
"immovable",
"immoveable",
"immune",
"immunised",
"immunized",
"immunochemical",
"immunocompetent",
"immunodeficient",
"immunogenic",
"immunologic",
"immunological",
"immutable",
"impacted",
"impaired",
"impalpable",
"imparipinnate",
"impartial",
"impassable",
"impassioned",
"impassive",
"impatient",
"impeccable",
"impeccant",
"impecunious",
"impeded",
"impeding",
"impelled",
"impellent",
"impelling",
"impendent",
"impending",
"impenetrable",
"impenitent",
"imperative",
"imperceptible",
"imperfect",
"imperfectible",
"imperforate",
"imperial",
"imperialist",
"imperialistic",
"imperious",
"imperishable",
"impermanent",
"impermeable",
"impermissible",
"impersonal",
"impertinent",
"imperturbable",
"imperviable",
"impervious",
"impetiginous",
"impetuous",
"impious",
"impish",
"implacable",
"implanted",
"implausible",
"implemental",
"implemented",
"implicated",
"implicational",
"implicative",
"implicit",
"implike",
"imploring",
"impolite",
"impolitic",
"imponderable",
"important",
"imported",
"importunate",
"imposed",
"imposing",
"impossible",
"impotent",
"impoverished",
"impracticable",
"impractical",
"imprecise",
"impregnable",
"impressed",
"impressible",
"impressionable",
"impressionist",
"impressionistic",
"impressive",
"imprisoned",
"improbable",
"impromptu",
"improper",
"improvable",
"improved",
"improvident",
"improving",
"improvised",
"imprudent",
"impudent",
"impugnable",
"impuissant",
"impulsive",
"impure",
"imputable",
"imputrescible",
"inaccessible",
"inaccurate",
"inactive",
"inadequate",
"inadmissible",
"inadvertent",
"inadvisable",
"inaesthetic",
"inalienable",
"inalterable",
"inane",
"inanimate",
"inapplicable",
"inapposite",
"inappreciable",
"inappropriate",
"inapt",
"inarguable",
"inarticulate",
"inartistic",
"inattentive",
"inaudible",
"inaugural",
"inauspicious",
"inauthentic",
"inboard",
"inborn",
"inbound",
"inbred",
"inbuilt",
"incalculable",
"incan",
"incandescent",
"incapable",
"incapacitated",
"incapacitating",
"incarnate",
"incased",
"incautious",
"incendiary",
"incensed",
"inceptive",
"incertain",
"incessant",
"incestuous",
"inchoate",
"inchoative",
"incident",
"incidental",
"incipient",
"incised",
"incisive",
"incitive",
"inclement",
"inclined",
"included",
"inclusive",
"incognito",
"incognizable",
"incognizant",
"incognoscible",
"incoherent",
"incombustible",
"incoming",
"incommensurable",
"incommensurate",
"incommodious",
"incommunicado",
"incommunicative",
"incommutable",
"incomparable",
"incompatible",
"incompetent",
"incomplete",
"incomprehensive",
"incompressible",
"incomputable",
"inconceivable",
"inconclusive",
"incongruent",
"incongruous",
"inconsequent",
"inconsequential",
"inconsiderable",
"inconsiderate",
"inconsistent",
"inconsolable",
"inconspicuous",
"inconstant",
"incontestable",
"incontestible",
"incontinent",
"inconvenient",
"inconvertible",
"incorporate",
"incorporated",
"incorporative",
"incorporeal",
"incorrect",
"incorrigible",
"incorrupt",
"incorrupted",
"incorruptible",
"increased",
"increasing",
"incredible",
"incredulous",
"incremental",
"incriminating",
"incriminatory",
"inculpable",
"inculpative",
"inculpatory",
"incumbent",
"incurable",
"incurious",
"incursive",
"incurvate",
"incurved",
"indebted",
"indecent",
"indecipherable",
"indecisive",
"indecorous",
"indefatigable",
"indefeasible",
"indefensible",
"indefinable",
"indefinite",
"indehiscent",
"indelible",
"indelicate",
"indentured",
"independent",
"indescribable",
"indestructible",
"indeterminable",
"indeterminate",
"indexical",
"indexless",
"indian",
"indicative",
"indicatory",
"indictable",
"indie",
"indifferent",
"indigenous",
"indigent",
"indigestible",
"indignant",
"indigo",
"indirect",
"indiscernible",
"indiscreet",
"indiscrete",
"indiscriminate",
"indispensable",
"indisposed",
"indisputable",
"indissoluble",
"indistinct",
"individual",
"individualised",
"individualist",
"individualistic",
"individualized",
"indivisible",
"indocile",
"indolent",
"indomitable",
"indonesian",
"indoor",
"indrawn",
"indubitable",
"induced",
"inducive",
"inductive",
"indulgent",
"indurate",
"indusial",
"industrial",
"industrialised",
"industrialized",
"industrious",
"indwelling",
"inebriated",
"inedible",
"ineffable",
"ineffective",
"ineffectual",
"inefficacious",
"inefficient",
"inelaborate",
"inelastic",
"inelegant",
"ineligible",
"ineluctable",
"inept",
"inequitable",
"ineradicable",
"inerrable",
"inerrant",
"inert",
"inertial",
"inescapable",
"inessential",
"inestimable",
"inevitable",
"inexact",
"inexcusable",
"inexhaustible",
"inexorable",
"inexpedient",
"inexpensive",
"inexperienced",
"inexperient",
"inexpert",
"inexpiable",
"inexplicable",
"inexplicit",
"inexpressible",
"inexpressive",
"inexpugnable",
"inexpungeable",
"inexpungible",
"inextensible",
"inexterminable",
"inextirpable",
"inextricable",
"infallible",
"infamous",
"infantile",
"infatuated",
"infeasible",
"infected",
"infectious",
"infective",
"infelicitous",
"inferential",
"inferior",
"infernal",
"infertile",
"infinite",
"infinitesimal",
"infinitival",
"infirm",
"inflamed",
"inflammable",
"inflammatory",
"inflatable",
"inflated",
"inflationary",
"inflected",
"inflectional",
"inflexible",
"inflowing",
"influent",
"influential",
"informal",
"informational",
"informative",
"informatory",
"informed",
"infrahuman",
"inframaxillary",
"infrangible",
"infrared",
"infrasonic",
"infrequent",
"infuriated",
"infuriating",
"ingenious",
"ingenuous",
"inglorious",
"ingrained",
"ingratiating",
"ingratiatory",
"ingrowing",
"ingrown",
"inguinal",
"inhabitable",
"inhabited",
"inhalant",
"inharmonic",
"inharmonious",
"inherent",
"inheritable",
"inherited",
"inheriting",
"inhibited",
"inhibitory",
"inhomogeneous",
"inhospitable",
"inhuman",
"inhumane",
"inhumed",
"inimical",
"inimitable",
"iniquitous",
"initial",
"initiative",
"initiatory",
"injectable",
"injudicious",
"injured",
"injurious",
"inky",
"inlaid",
"inland",
"inmost",
"innate",
"inner",
"innermost",
"innocent",
"innocuous",
"innovational",
"innovative",
"innoxious",
"innumerable",
"innumerate",
"innumerous",
"inodorous",
"inoffensive",
"inoperable",
"inoperative",
"inopportune",
"inordinate",
"inorganic",
"inpouring",
"inquiring",
"inquisitive",
"inquisitorial",
"inquisitory",
"insalubrious",
"insane",
"insanitary",
"insatiable",
"insatiate",
"inscribed",
"inscriptive",
"inscrutable",
"insectan",
"insecticidal",
"insectivorous",
"insecure",
"insensate",
"insensible",
"insensitive",
"insentient",
"inseparable",
"inshore",
"inside",
"insidious",
"insightful",
"insignificant",
"insincere",
"insinuating",
"insipid",
"insistent",
"insolent",
"insoluble",
"insolvable",
"insolvent",
"insomniac",
"insouciant",
"inspirational",
"inspiratory",
"inspired",
"inspiring",
"inspiriting",
"inst",
"instant",
"instantaneous",
"instigative",
"instinct",
"instinctive",
"institutional",
"instructional",
"instructive",
"instrumental",
"insubordinate",
"insubstantial",
"insufferable",
"insufficient",
"insular",
"insulting",
"insuperable",
"insupportable",
"insurable",
"insured",
"insurgent",
"insurmountable",
"insurrectional",
"insurrectionary",
"insusceptible",
"intact",
"intangible",
"integral",
"integrated",
"integrative",
"integumental",
"integumentary",
"intellectual",
"intelligent",
"intelligible",
"intemperate",
"intended",
"intense",
"intensified",
"intensifying",
"intensional",
"intensive",
"intent",
"intentional",
"interactional",
"interactive",
"interbred",
"intercalary",
"intercellular",
"interchangeable",
"interchurch",
"intercollegiate",
"interconnected",
"intercostal",
"intercrossed",
"interdependent",
"interested",
"interesting",
"interfacial",
"interfaith",
"interfering",
"intergalactic",
"interim",
"interior",
"interlaced",
"interlacing",
"interlineal",
"interlinear",
"interlinking",
"interlobular",
"interlocking",
"interlocutory",
"intermediate",
"intermeshed",
"interminable",
"intermittent",
"intermolecular",
"intermural",
"internal",
"international",
"internecine",
"interoceptive",
"interoperable",
"interpersonal",
"interplanetary",
"interpretable",
"interpretative",
"interpreted",
"interpretive",
"interracial",
"interred",
"interrelated",
"interrogative",
"interrogatory",
"interrupted",
"interscholastic",
"interschool",
"intersectant",
"intersecting",
"intersexual",
"interspecies",
"interspecific",
"interstate",
"interstellar",
"interstitial",
"intertidal",
"intertribal",
"intervening",
"intervertebral",
"interwoven",
"intestate",
"intestinal",
"intimal",
"intimate",
"intimidated",
"intimidating",
"intolerable",
"intolerant",
"intoned",
"intoxicant",
"intoxicated",
"intoxicating",
"intracellular",
"intracerebral",
"intracranial",
"intractable",
"intracutaneous",
"intradermal",
"intradermic",
"intragroup",
"intralinguistic",
"intralobular",
"intramolecular",
"intramural",
"intramuscular",
"intransigent",
"intransitive",
"intrapulmonary",
"intrasentential",
"intraspecies",
"intraspecific",
"intrastate",
"intrauterine",
"intravenous",
"intrepid",
"intricate",
"intriguing",
"intrinsic",
"intrinsical",
"introductory",
"introjected",
"introspective",
"introuvable",
"introversive",
"introverted",
"introvertish",
"introvertive",
"intruding",
"intrusive",
"intuitionist",
"intuitive",
"intumescent",
"inundated",
"inured",
"inutile",
"invading",
"invalid",
"invalidated",
"invalidating",
"invaluable",
"invariable",
"invariant",
"invasive",
"inventive",
"inverse",
"invertebrate",
"inverted",
"invertible",
"investigative",
"investigatory",
"inveterate",
"invidious",
"invigorated",
"invigorating",
"invincible",
"inviolable",
"inviolate",
"invisible",
"invitational",
"invitatory",
"inviting",
"involucrate",
"involuntary",
"involute",
"involved",
"invulnerable",
"inward",
"inwrought",
"iodinated",
"iodinating",
"iodised",
"iodized",
"ionian",
"ionic",
"ionised",
"ionized",
"ipsilateral",
"iraki",
"iranian",
"iraqi",
"irascible",
"irate",
"ireful",
"irenic",
"iridaceous",
"iridescent",
"iridic",
"irish",
"iritic",
"irksome",
"iron",
"ironclad",
"ironed",
"ironic",
"ironical",
"ironlike",
"ironshod",
"irrational",
"irreclaimable",
"irreconcilable",
"irrecoverable",
"irredeemable",
"irreducible",
"irrefutable",
"irregular",
"irrelevant",
"irreligious",
"irremediable",
"irremovable",
"irreparable",
"irreplaceable",
"irrepressible",
"irreproachable",
"irreproducible",
"irresistible",
"irresolute",
"irresponsible",
"irretrievable",
"irreverent",
"irreversible",
"irrevocable",
"irrevokable",
"irritable",
"irritated",
"irritating",
"irritative",
"irruptive",
"ischaemic",
"ischemic",
"isentropic",
"islamic",
"ismaili",
"isobilateral",
"isochronal",
"isochronous",
"isoclinal",
"isoclinic",
"isocyclic",
"isogonic",
"isolable",
"isolated",
"isolating",
"isolationist",
"isolationistic",
"isomeric",
"isometric",
"isometrical",
"isomorphic",
"isomorphous",
"isopteran",
"isosceles",
"isosmotic",
"isothermal",
"isothermic",
"isotonic",
"isotopic",
"isotropic",
"isotropous",
"israeli",
"isthmian",
"italian",
"italic",
"itchy",
"iterative",
"itinerant",
"ivied",
"jacksonian",
"jacobean",
"jacobinic",
"jacobinical",
"jade",
"jaded",
"jagged",
"jaggy",
"jailed",
"jain",
"jainist",
"jamaican",
"jamesian",
"jammed",
"jangling",
"jangly",
"japanese",
"jarring",
"jaundiced",
"jaunty",
"javan",
"javanese",
"jawed",
"jawless",
"jazzy",
"jealous",
"jeering",
"jeffersonian",
"jejune",
"jelled",
"jellied",
"jellylike",
"jerking",
"jerkwater",
"jerky",
"jesting",
"jesuit",
"jesuitic",
"jesuitical",
"jetting",
"jeweled",
"jewelled",
"jewish",
"jiggered",
"jihadi",
"jilted",
"jingling",
"jingly",
"jingoistic",
"jinxed",
"jittering",
"jittery",
"jobless",
"jocose",
"jocular",
"jocund",
"joined",
"joint",
"jointed",
"joking",
"jolly",
"jolted",
"jolting",
"jolty",
"jordanian",
"journalistic",
"jovial",
"jovian",
"jowly",
"joyful",
"joyless",
"joyous",
"jubilant",
"judaic",
"judaical",
"judgmental",
"judicable",
"judicial",
"judicious",
"jugular",
"juiceless",
"juicy",
"julian",
"jumbled",
"jumbo",
"jumentous",
"jumpy",
"jungian",
"jungly",
"junior",
"junoesque",
"jural",
"jurassic",
"juridic",
"juridical",
"jurisdictional",
"jurisprudential",
"juristic",
"just",
"justifiable",
"justificative",
"justificatory",
"justified",
"jutting",
"juvenile",
"juxtaposed",
"kabbalistic",
"kafkaesque",
"kaleidoscopic",
"kaleidoscopical",
"kampuchean",
"kantian",
"kaput",
"karyokinetic",
"kashmiri",
"katabatic",
"katabolic",
"katari",
"katharobic",
"kayoed",
"kazakhstani",
"kechuan",
"keeled",
"keen",
"kempt",
"kenyan",
"kept",
"keyed",
"keyless",
"keynesian",
"khaki",
"killable",
"killing",
"kinaesthetic",
"kind",
"kindhearted",
"kindled",
"kindly",
"kindred",
"kinesthetic",
"kinetic",
"kinglike",
"kingly",
"kinky",
"kiplingesque",
"kitschy",
"kittenish",
"knackered",
"knavish",
"knifelike",
"knightly",
"knitted",
"knobbed",
"knobbly",
"knobby",
"knockabout",
"knockdown",
"knockout",
"knotted",
"knotty",
"knowable",
"knowing",
"knowledgeable",
"known",
"kokka",
"kookie",
"kooky",
"koranic",
"korean",
"kosher",
"kurdish",
"kuwaiti",
"kyphotic",
"kyrgyzstani",
"labeled",
"labelled",
"labial",
"labiate",
"labile",
"labored",
"laboring",
"laborious",
"laborsaving",
"laboured",
"labouring",
"laboursaving",
"labyrinthian",
"labyrinthine",
"laced",
"lacelike",
"lacerate",
"lacerated",
"lacertilian",
"lachrymal",
"lachrymatory",
"lachrymose",
"laciniate",
"lackadaisical",
"lacking",
"lackluster",
"lacklustre",
"laconic",
"lacrimal",
"lacrimatory",
"lactating",
"lacteal",
"lactic",
"lactogenic",
"lacustrine",
"lacy",
"laden",
"ladened",
"ladylike",
"laggard",
"laic",
"laid",
"lamarckian",
"lambent",
"lamblike",
"lame",
"lamellibranch",
"lamentable",
"lamented",
"lamenting",
"laminal",
"laminar",
"lamplit",
"lanate",
"lancastrian",
"lancelike",
"lanceolate",
"lancinate",
"lancinating",
"landed",
"landless",
"landlocked",
"landlubberly",
"landscaped",
"languid",
"languorous",
"laniary",
"lank",
"lanky",
"laotian",
"lapidarian",
"lapidary",
"lapsed",
"laputan",
"larboard",
"large",
"larger",
"larghetto",
"larghissimo",
"largish",
"largo",
"larval",
"laryngeal",
"lascivious",
"lashing",
"last",
"lasting",
"late",
"lateen",
"latent",
"later",
"lateral",
"latest",
"lathery",
"latin",
"latinate",
"latino",
"latish",
"latitudinal",
"latitudinarian",
"latter",
"latticed",
"latticelike",
"latvian",
"laudable",
"laudatory",
"laughable",
"laughing",
"laureate",
"laureled",
"laurelled",
"lavender",
"lavish",
"lawful",
"lawless",
"laxative",
"layered",
"lazy",
"leaded",
"leaden",
"leading",
"leadless",
"leafed",
"leafless",
"leaflike",
"leafy",
"leakproof",
"leaky",
"leal",
"lean",
"leaning",
"learned",
"leased",
"least",
"leathered",
"leatherlike",
"leathery",
"leaved",
"leavened",
"lebanese",
"lecherous",
"leechlike",
"leering",
"leery",
"leeward",
"left",
"leftish",
"leftist",
"leftmost",
"leftover",
"legal",
"legato",
"legendary",
"legged",
"leggy",
"legible",
"legion",
"legislative",
"legitimate",
"legless",
"leglike",
"leguminous",
"leibnitzian",
"leibnizian",
"leisured",
"leisurely",
"lemonlike",
"lemony",
"lendable",
"lengthened",
"lengthways",
"lengthwise",
"lengthy",
"lenient",
"lenitive",
"lenten",
"lentic",
"lenticular",
"lentiform",
"lentiginose",
"lentiginous",
"lentissimo",
"lento",
"leonardesque",
"leonine",
"lepidote",
"leprose",
"leprous",
"leptorhine",
"leptorrhine",
"leptorrhinian",
"leptorrhinic",
"lesbian",
"less",
"lessened",
"lesser",
"lethal",
"lethargic",
"lettered",
"levantine",
"level",
"levelheaded",
"levitical",
"levorotary",
"levorotatory",
"lewd",
"lexical",
"lexicalised",
"lexicalized",
"lexicographic",
"lexicographical",
"lexicostatistic",
"liable",
"libellous",
"libelous",
"liberal",
"liberalistic",
"liberated",
"liberian",
"libertine",
"libidinal",
"libidinous",
"libyan",
"licenced",
"licensed",
"licentious",
"licit",
"licked",
"lidded",
"lidless",
"liechtensteiner",
"liege",
"lienal",
"lifeless",
"lifelike",
"lifelong",
"lifesize",
"lifted",
"light",
"lighted",
"lightheaded",
"lighthearted",
"lightless",
"lightproof",
"lightsome",
"lightweight",
"ligneous",
"liii",
"likable",
"like",
"likeable",
"liked",
"likely",
"lilac",
"liliaceous",
"lilliputian",
"lilting",
"limacine",
"limacoid",
"limbed",
"limber",
"limbic",
"limbless",
"limited",
"limiting",
"limitless",
"limnological",
"limp",
"limpid",
"lincolnesque",
"lincolnian",
"lineal",
"linear",
"lined",
"linelike",
"lingual",
"linguistic",
"lingulate",
"linked",
"linnaean",
"linnean",
"lionhearted",
"lipless",
"liplike",
"lipophilic",
"lipotropic",
"lipped",
"liquefiable",
"liquefied",
"liquescent",
"liquid",
"liquifiable",
"liquified",
"lissom",
"lissome",
"listed",
"listless",
"lite",
"literal",
"literary",
"literate",
"lithe",
"lithesome",
"lithic",
"lithographic",
"lithomantic",
"lithophytic",
"lithuanian",
"litigious",
"littered",
"little",
"littler",
"littoral",
"liturgical",
"livable",
"live",
"liveable",
"liveborn",
"livelong",
"lively",
"liver",
"liveried",
"liverish",
"liverpudlian",
"livery",
"livid",
"living",
"loaded",
"loamless",
"loamy",
"loath",
"loathly",
"loathsome",
"lobar",
"lobate",
"lobated",
"lobed",
"lobeliaceous",
"lobular",
"local",
"localised",
"localized",
"located",
"loco",
"locomotive",
"locomotor",
"lofty",
"logarithmic",
"loggerheaded",
"logical",
"logistic",
"logistical",
"logogrammatic",
"logographic",
"logy",
"lone",
"lonely",
"lonesome",
"long",
"longanimous",
"longhand",
"longish",
"longitudinal",
"longsighted",
"longstanding",
"longtime",
"looking",
"loony",
"loopy",
"loose",
"looseleaf",
"loosened",
"looted",
"lopsided",
"loquacious",
"lordless",
"lordly",
"lordotic",
"lossless",
"lossy",
"lost",
"loth",
"lotic",
"louche",
"loud",
"lousy",
"loutish",
"louvered",
"lovable",
"loveable",
"loved",
"loveless",
"lovelorn",
"lovely",
"loverlike",
"loverly",
"lovesick",
"lovesome",
"loving",
"lowborn",
"lowbred",
"lowbrow",
"lowbrowed",
"lowercase",
"lowered",
"lowering",
"lowermost",
"lowest",
"lowland",
"lowly",
"lowset",
"loyal",
"lubberly",
"lubricated",
"lubricious",
"lucent",
"lucid",
"lucifugal",
"lucifugous",
"luckless",
"lucky",
"lucrative",
"luculent",
"lucullan",
"ludic",
"ludicrous",
"lugubrious",
"lukewarm",
"lumbar",
"lumbering",
"lumbosacral",
"luminescent",
"luminous",
"lumpen",
"lumpish",
"lumpy",
"lunar",
"lunate",
"lunatic",
"lunisolar",
"lupine",
"lurid",
"luscious",
"lush",
"lusitanian",
"lusterless",
"lustful",
"lustreless",
"lustrous",
"lusty",
"luteal",
"lutheran",
"luxe",
"luxembourgian",
"luxemburger",
"luxuriant",
"luxurious",
"lvii",
"lviii",
"lxii",
"lxiii",
"lxiv",
"lxvi",
"lxvii",
"lxviii",
"lxxi",
"lxxii",
"lxxiii",
"lxxiv",
"lxxv",
"lxxvi",
"lxxvii",
"lxxviii",
"lxxx",
"lxxxi",
"lxxxii",
"lxxxiii",
"lxxxiv",
"lxxxv",
"lxxxvi",
"lxxxvii",
"lxxxviii",
"lymphatic",
"lymphocytic",
"lymphoid",
"lyonnaise",
"lyophilised",
"lyophilized",
"lyrate",
"lyric",
"lyrical",
"lysogenic",
"macabre",
"macaronic",
"macedonian",
"macerative",
"machiavellian",
"machinelike",
"macho",
"macrencephalic",
"macrencephalous",
"macro",
"macrobiotic",
"macrocephalic",
"macrocephalous",
"macrocosmic",
"macroeconomic",
"macromolecular",
"macroscopic",
"macroscopical",
"maculate",
"madagascan",
"madcap",
"maddened",
"maddening",
"made",
"magenta",
"maggoty",
"magic",
"magical",
"magisterial",
"magnanimous",
"magnetic",
"magnetised",
"magnetized",
"magnificent",
"magnified",
"magniloquent",
"magyar",
"maiden",
"maidenlike",
"maidenly",
"mailed",
"maimed",
"main",
"mainstreamed",
"maintainable",
"maintained",
"majestic",
"major",
"majuscular",
"majuscule",
"makeshift",
"maladaptive",
"maladjusted",
"maladjustive",
"maladroit",
"malapropos",
"malarial",
"malawian",
"malay",
"malayan",
"malaysian",
"malcontent",
"male",
"maledict",
"malefic",
"maleficent",
"malevolent",
"malformed",
"malfunctioning",
"malian",
"malicious",
"malign",
"malignant",
"malleable",
"malnourished",
"malodorous",
"malodourous",
"malposed",
"malted",
"maltese",
"malthusian",
"maltreated",
"mammalian",
"mammary",
"mammoth",
"manageable",
"managerial",
"manchurian",
"mancunian",
"mandaean",
"mandatory",
"mandean",
"mandibular",
"mandibulate",
"mandibulofacial",
"maneuverable",
"manful",
"mangey",
"mangled",
"mangy",
"maniac",
"maniacal",
"manic",
"manichaean",
"manichean",
"manichee",
"maniclike",
"manifest",
"manifold",
"manipulable",
"manipulative",
"manky",
"manlike",
"manly",
"manned",
"mannered",
"mannerly",
"mannish",
"manoeuvrable",
"manorial",
"manque",
"mansard",
"mantic",
"mantled",
"manual",
"manufactured",
"manx",
"many",
"maoist",
"maplelike",
"marauding",
"marbled",
"marbleised",
"marbleized",
"marginal",
"marian",
"marine",
"marital",
"maritime",
"marked",
"marketable",
"markovian",
"marly",
"marmoreal",
"marmorean",
"maroc",
"maroon",
"marooned",
"marred",
"marriageable",
"married",
"marshy",
"marsupial",
"martial",
"martian",
"marvellous",
"marvelous",
"marxist",
"masculine",
"masked",
"masochistic",
"masonic",
"masoretic",
"mass",
"massive",
"masted",
"master",
"mastered",
"masterful",
"masterless",
"masterly",
"mastoid",
"mastoidal",
"matched",
"matching",
"matchless",
"mated",
"mateless",
"material",
"materialistic",
"maternal",
"maternalistic",
"matey",
"mathematical",
"matriarchal",
"matriarchic",
"matricentric",
"matrilineal",
"matrilinear",
"matrimonial",
"matronly",
"matt",
"matte",
"matted",
"maturational",
"mature",
"matured",
"matutinal",
"maudlin",
"mauritanian",
"mauritian",
"mauve",
"maverick",
"mawkish",
"maxi",
"maxillary",
"maxillodental",
"maxillofacial",
"maximal",
"maximising",
"maximizing",
"maximum",
"mayoral",
"mazed",
"mazy",
"meager",
"meagerly",
"meagre",
"mealy",
"mealymouthed",
"mean",
"meandering",
"meaning",
"meaningful",
"meaningless",
"meanspirited",
"measly",
"measurable",
"measured",
"measureless",
"meatless",
"meaty",
"mechanic",
"mechanical",
"mechanised",
"mechanistic",
"mechanized",
"mecopterous",
"meddlesome",
"meddling",
"mediaeval",
"medial",
"median",
"mediate",
"mediated",
"mediatorial",
"mediatory",
"medical",
"medicative",
"medicinal",
"medicolegal",
"medieval",
"mediocre",
"meditative",
"mediterranean",
"medium",
"medullary",
"medullated",
"medusoid",
"meek",
"meet",
"megakaryocytic",
"megalithic",
"megaloblastic",
"megalomaniacal",
"megalomanic",
"megascopic",
"meiotic",
"melancholic",
"melancholy",
"melanesian",
"meliorative",
"mellifluous",
"mellisonant",
"mellow",
"mellowed",
"melodic",
"melodious",
"melodramatic",
"meltable",
"melted",
"melting",
"membered",
"memberless",
"membranous",
"memorable",
"menacing",
"mendacious",
"mendelian",
"mendicant",
"menial",
"meningeal",
"menopausal",
"mensal",
"menstrual",
"mensurable",
"mensural",
"mental",
"mentholated",
"mephistophelean",
"mephistophelian",
"mephitic",
"mercantile",
"mercenary",
"mercerised",
"mercerized",
"merchantable",
"merciful",
"merciless",
"mercurial",
"mercuric",
"mercurous",
"mere",
"meretricious",
"merged",
"merging",
"meridian",
"meridional",
"meritable",
"merited",
"meritless",
"meritocratic",
"meritorious",
"merovingian",
"merry",
"mesenteric",
"meshed",
"meshuga",
"meshugga",
"meshugge",
"meshuggeneh",
"meshuggener",
"mesial",
"mesic",
"mesmeric",
"mesmerised",
"mesmerized",
"mesmerizing",
"mesoamerican",
"mesoblastic",
"mesodermal",
"mesolithic",
"mesomorphic",
"mesonic",
"mesophytic",
"mesozoic",
"messianic",
"messy",
"metabolic",
"metabolous",
"metacarpal",
"metacentric",
"metagrabolised",
"metagrabolized",
"metagrobolised",
"metagrobolized",
"metal",
"metallic",
"metallike",
"metalloid",
"metallurgic",
"metallurgical",
"metameric",
"metamorphic",
"metamorphous",
"metaphoric",
"metaphorical",
"metaphysical",
"metastable",
"metastatic",
"metatarsal",
"meteoric",
"meteoritic",
"meteoritical",
"meteorologic",
"meteorological",
"methodical",
"methodist",
"methodological",
"methylated",
"meticulous",
"metonymic",
"metonymical",
"metric",
"metrical",
"metrological",
"metropolitan",
"mettlesome",
"mexican",
"miasmal",
"miasmic",
"micaceous",
"micro",
"microbial",
"microbic",
"microcephalic",
"microcephalous",
"microcosmic",
"microeconomic",
"microelectronic",
"micrometeoric",
"micrometeoritic",
"micropylar",
"microscopic",
"microscopical",
"microsomal",
"middle",
"middlemost",
"middling",
"midget",
"midi",
"midland",
"midmost",
"midway",
"midweekly",
"midwestern",
"miffed",
"mighty",
"migrant",
"migrational",
"migratory",
"milanese",
"milch",
"mild",
"militant",
"militarised",
"militaristic",
"militarized",
"military",
"milkless",
"milklike",
"milky",
"milled",
"millenarian",
"millenary",
"millennial",
"millennian",
"million",
"millionth",
"mimetic",
"mimic",
"minacious",
"minatory",
"mincing",
"minded",
"mindful",
"mindless",
"mined",
"mineral",
"mingy",
"mini",
"miniature",
"minimal",
"minimalist",
"minimized",
"minimum",
"miniscule",
"ministerial",
"ministrant",
"minoan",
"minor",
"mint",
"minty",
"minus",
"minuscular",
"minuscule",
"minute",
"miotic",
"miraculous",
"mired",
"mirky",
"mirrored",
"mirrorlike",
"mirthful",
"mirthless",
"miry",
"misanthropic",
"misanthropical",
"misappropriated",
"misbegot",
"misbegotten",
"misbranded",
"miscellaneous",
"mischievous",
"miscible",
"miserable",
"miserly",
"misfortunate",
"misguided",
"mishnaic",
"mislabeled",
"mislaid",
"misleading",
"mismatched",
"mismated",
"misogynic",
"misogynistic",
"misogynous",
"misplaced",
"misrelated",
"misrepresented",
"missed",
"misshapen",
"missing",
"missional",
"missionary",
"mistakable",
"mistaken",
"mistreated",
"mistrustful",
"misty",
"misunderstood",
"misused",
"mithraic",
"mithraistic",
"mitigable",
"mitigated",
"mitigative",
"mitigatory",
"mitotic",
"mitral",
"mixable",
"mixed",
"mnemonic",
"mnemotechnic",
"mnemotechnical",
"moated",
"mobbish",
"mobile",
"moblike",
"mock",
"mocking",
"modal",
"model",
"modeled",
"moderate",
"moderating",
"moderato",
"modern",
"moderne",
"modernised",
"modernistic",
"modernized",
"modest",
"modifiable",
"modified",
"modish",
"modular",
"modulated",
"mohammedan",
"moire",
"moist",
"molal",
"molar",
"moldable",
"molded",
"moldovan",
"moldy",
"molecular",
"molten",
"momentaneous",
"momentary",
"momentous",
"monacan",
"monandrous",
"monarchal",
"monarchic",
"monarchical",
"monastic",
"monastical",
"monatomic",
"monaural",
"monecious",
"monegasque",
"moneran",
"monestrous",
"monetary",
"moneyed",
"moneyless",
"moneymaking",
"mongol",
"mongolian",
"mongoloid",
"monied",
"monistic",
"monitory",
"monkish",
"mono",
"monoatomic",
"monocarboxylic",
"monocarpic",
"monochromatic",
"monochrome",
"monochromic",
"monochromous",
"monocled",
"monoclinal",
"monoclinic",
"monoclinous",
"monoclonal",
"monodic",
"monodical",
"monoecious",
"monoestrous",
"monogamous",
"monogenic",
"monogynic",
"monogynous",
"monoicous",
"monolingual",
"monolithic",
"monomaniacal",
"monometallic",
"monomorphemic",
"mononuclear",
"mononucleate",
"monophonic",
"monophysite",
"monophysitic",
"monoploid",
"monopolistic",
"monopteral",
"monosemous",
"monosyllabic",
"monotheistic",
"monotone",
"monotonic",
"monotonous",
"monotypic",
"monounsaturated",
"monovalent",
"monovular",
"monozygotic",
"monstrous",
"montane",
"monthlong",
"monthly",
"montserratian",
"monumental",
"moody",
"moonless",
"moonlike",
"moonlit",
"moonstruck",
"moony",
"moorish",
"moot",
"moraceous",
"moral",
"moralistic",
"moravian",
"morbid",
"morbific",
"morbilliform",
"mordacious",
"mordant",
"more",
"moresque",
"morganatic",
"moribund",
"mormon",
"moroccan",
"moronic",
"morose",
"morphemic",
"morphologic",
"morphological",
"morphophonemic",
"mortal",
"mortgaged",
"mortified",
"mortifying",
"mortuary",
"mosaic",
"moslem",
"mosstone",
"mossy",
"most",
"motherless",
"motherlike",
"motherly",
"mothproof",
"mothy",
"motile",
"motional",
"motionless",
"motivated",
"motivating",
"motivational",
"motivative",
"motive",
"motiveless",
"motley",
"motor",
"motored",
"motorial",
"motorised",
"motorized",
"motorless",
"mottled",
"mouldy",
"mountainous",
"mounted",
"mournful",
"mourning",
"mouselike",
"mousey",
"mousy",
"mouthless",
"mouthlike",
"movable",
"moveable",
"moved",
"moving",
"mown",
"mozambican",
"mozartean",
"mozartian",
"much",
"muciferous",
"mucilaginous",
"mucinoid",
"mucinous",
"mucky",
"mucocutaneous",
"mucoid",
"mucoidal",
"mucopurulent",
"mucosal",
"mucose",
"mucous",
"muddied",
"muddled",
"muddleheaded",
"muddy",
"muffled",
"muggy",
"muhammadan",
"mulish",
"mullioned",
"multicellular",
"multicolor",
"multicolored",
"multicolour",
"multicoloured",
"multicultural",
"multiethnic",
"multifaceted",
"multifactorial",
"multifarious",
"multiform",
"multilane",
"multilateral",
"multilevel",
"multilingual",
"multinational",
"multinomial",
"multinucleate",
"multiparous",
"multipartite",
"multiphase",
"multiple",
"multiplex",
"multiplicative",
"multiplied",
"multipotent",
"multipurpose",
"multiracial",
"multistorey",
"multistoried",
"multistory",
"multitudinous",
"multivalent",
"multivariate",
"mundane",
"municipal",
"munificent",
"mural",
"murdered",
"murderous",
"murine",
"murky",
"murmuring",
"murmurous",
"muscovite",
"muscular",
"musculoskeletal",
"mushy",
"musical",
"musicological",
"musing",
"musky",
"muslim",
"mussy",
"must",
"mustached",
"mustachioed",
"musty",
"mutable",
"mutafacient",
"mutagenic",
"mutant",
"mutational",
"mutative",
"mute",
"muted",
"mutilated",
"mutinous",
"mutual",
"mutualist",
"muzzy",
"myalgic",
"mycenaean",
"myelic",
"myelinated",
"myelinic",
"myeloid",
"myocardial",
"myoid",
"myopathic",
"myopic",
"myotic",
"myotonic",
"myriad",
"myrmecophagous",
"myrmecophilous",
"myrmecophytic",
"mysophobic",
"mysterious",
"mystic",
"mystical",
"mystified",
"mystifying",
"mythic",
"mythical",
"mythologic",
"mythological",
"nacreous",
"nagging",
"naiant",
"naif",
"naive",
"naked",
"nameless",
"namibian",
"naming",
"nanocephalic",
"napoleonic",
"napped",
"napping",
"nappy",
"narcissistic",
"narcoleptic",
"narcotic",
"narcotised",
"narcotising",
"narcotized",
"narcotizing",
"narial",
"narrative",
"narrow",
"narrowed",
"narrowing",
"nary",
"nasal",
"nascent",
"nasopharyngeal",
"nasty",
"natal",
"national",
"nationalist",
"nationalistic",
"nationwide",
"native",
"nativist",
"nativistic",
"natriuretic",
"natty",
"natural",
"naturalised",
"naturalistic",
"naturalized",
"naturistic",
"naughty",
"nauruan",
"nauseated",
"nauseating",
"nauseous",
"nautical",
"naval",
"navicular",
"navigable",
"navigational",
"nazarene",
"nazi",
"neandertal",
"neanderthal",
"neanderthalian",
"neapolitan",
"near",
"nearby",
"nearsighted",
"neat",
"nebular",
"nebulose",
"nebulous",
"necessary",
"necessitous",
"necked",
"neckless",
"necklike",
"necromantic",
"necromantical",
"necrotic",
"nectariferous",
"nectarous",
"needed",
"needful",
"needled",
"needlelike",
"needless",
"needy",
"nefarious",
"negative",
"neglected",
"neglectful",
"negligent",
"negligible",
"negotiable",
"negro",
"neighboring",
"neighborly",
"neighbourly",
"neither",
"neoclassic",
"neoclassical",
"neoclassicist",
"neoclassicistic",
"neocortical",
"neoliberal",
"neolithic",
"neonatal",
"neoplastic",
"neotenic",
"neotenous",
"nepalese",
"nepali",
"nephritic",
"nephrotoxic",
"neritic",
"nerveless",
"nervous",
"nervy",
"nescient",
"nestled",
"nestorian",
"nether",
"nethermost",
"netlike",
"nett",
"netted",
"nettled",
"nettlesome",
"networklike",
"neural",
"neuralgic",
"neurasthenic",
"neuroanatomic",
"neuroanatomical",
"neurobiological",
"neuroendocrine",
"neurogenic",
"neuroglial",
"neurologic",
"neurological",
"neuromatous",
"neuromotor",
"neuromuscular",
"neuronal",
"neuronic",
"neurotic",
"neurotoxic",
"neurotropic",
"neuter",
"neutered",
"neutral",
"neutralised",
"neutralized",
"newborn",
"newfangled",
"newfound",
"newsless",
"newsworthy",
"newsy",
"newtonian",
"next",
"nibbed",
"nicaean",
"nicaraguan",
"nice",
"nicene",
"nidicolous",
"nidifugous",
"niffy",
"nifty",
"nigerian",
"nigerien",
"niggardly",
"niggling",
"nigh",
"nighted",
"nightlong",
"nightly",
"nightmarish",
"nihilistic",
"nilotic",
"nilpotent",
"nimble",
"nine",
"ninefold",
"ninepenny",
"nineteen",
"nineteenth",
"ninetieth",
"ninety",
"ninth",
"nipping",
"nipponese",
"nippy",
"nisi",
"nitid",
"nitric",
"nitrogenous",
"nitrous",
"nitwitted",
"noachian",
"noble",
"nocent",
"nociceptive",
"noctilucent",
"nocturnal",
"nodding",
"nodular",
"nodulated",
"noduled",
"nodulose",
"noetic",
"noiseless",
"noisome",
"noisy",
"nomadic",
"nominal",
"nominalistic",
"nominated",
"nominative",
"nomothetic",
"nonabsorbent",
"nonabsorptive",
"nonadaptive",
"nonaddictive",
"nonadhesive",
"nonadjacent",
"nonadsorbent",
"nonadsorptive",
"nonaged",
"nonagenarian",
"nonaggressive",
"nonalcoholic",
"nonaligned",
"nonappointive",
"nonarbitrable",
"nonarbitrary",
"nonarboreal",
"nonassertive",
"nonassociative",
"nonastringent",
"nonautonomous",
"nonbearing",
"nonbelligerent",
"noncaloric",
"noncarbonated",
"noncausal",
"noncausative",
"noncellular",
"nonchalant",
"nonchristian",
"nonchurchgoing",
"noncivilised",
"noncivilized",
"nonclassical",
"noncollapsable",
"noncollapsible",
"noncolumned",
"noncombatant",
"noncombinative",
"noncombining",
"noncombustible",
"noncommercial",
"noncommissioned",
"noncommittal",
"noncommunicable",
"noncompetitive",
"noncompliant",
"nonconcentric",
"nonconducting",
"nonconductive",
"nonconforming",
"nonconformist",
"nonconscious",
"noncontagious",
"noncontentious",
"noncontinuous",
"nonconvergent",
"noncritical",
"noncrucial",
"noncrystalline",
"noncurrent",
"noncyclic",
"noncyclical",
"nondeductible",
"nondescript",
"nondigestible",
"nondisposable",
"none",
"nonechoic",
"noneffervescent",
"nonelected",
"nonelective",
"nonenterprising",
"nonenzymatic",
"nonequivalent",
"nonessential",
"nonexempt",
"nonexistent",
"nonexplorative",
"nonexploratory",
"nonexplosive",
"nonextant",
"nonextensile",
"nonfat",
"nonfatal",
"nonfictional",
"nonfigurative",
"nonfinancial",
"nonfinite",
"nonfissile",
"nonfissionable",
"nonflammable",
"nonflavored",
"nonflavoured",
"nonflowering",
"nonfunctional",
"nonglutinous",
"nongranular",
"nongregarious",
"nonhairy",
"nonharmonic",
"nonhereditary",
"nonheritable",
"nonhierarchic",
"nonhierarchical",
"nonhuman",
"nonimitative",
"nonimmune",
"nonindulgent",
"nonindustrial",
"noninfectious",
"noninflammatory",
"noninheritable",
"nonintegrated",
"nonintellectual",
"nonintersecting",
"noninvasive",
"nonionic",
"nonionised",
"nonionized",
"nonjudgmental",
"nonkosher",
"nonleaded",
"nonlegal",
"nonlethal",
"nonlexical",
"nonlinear",
"nonlinguistic",
"nonliteral",
"nonliterary",
"nonliterate",
"nonliving",
"nonmagnetic",
"nonmandatory",
"nonmaterial",
"nonmeaningful",
"nonmechanical",
"nonmechanistic",
"nonmedicinal",
"nonmetal",
"nonmetallic",
"nonmetamorphic",
"nonmigratory",
"nonmilitary",
"nonmodern",
"nonmonotonic",
"nonmotile",
"nonmoving",
"nonmusical",
"nonnative",
"nonnatural",
"nonnegative",
"nonnomadic",
"nonnormative",
"nonobjective",
"nonobligatory",
"nonobservant",
"nonopening",
"nonoperational",
"nonoscillatory",
"nonparallel",
"nonparametric",
"nonparasitic",
"nonpareil",
"nonparticulate",
"nonpartisan",
"nonpartizan",
"nonpasserine",
"nonperiodic",
"nonpersonal",
"nonphysical",
"nonplused",
"nonplussed",
"nonpoisonous",
"nonpolar",
"nonpolitical",
"nonporous",
"nonpregnant",
"nonprehensile",
"nonprescription",
"nonproductive",
"nonprofessional",
"nonprofit",
"nonprogressive",
"nonproprietary",
"nonprotractile",
"nonpsychoactive",
"nonpublic",
"nonpurulent",
"nonracial",
"nonracist",
"nonradioactive",
"nonrandom",
"nonrational",
"nonreciprocal",
"nonrecreational",
"nonreflecting",
"nonreflective",
"nonrenewable",
"nonrepetitive",
"nonresident",
"nonresidential",
"nonresilient",
"nonresinous",
"nonresiny",
"nonresistant",
"nonresonant",
"nonrestrictive",
"nonreticulate",
"nonretractable",
"nonretractile",
"nonreturnable",
"nonreversible",
"nonrhythmic",
"nonrigid",
"nonruminant",
"nonsectarian",
"nonsegmental",
"nonsegregated",
"nonsense",
"nonsensical",
"nonsensitive",
"nonsexual",
"nonsignificant",
"nonskid",
"nonslip",
"nonslippery",
"nonsocial",
"nonsovereign",
"nonspatial",
"nonspeaking",
"nonspecific",
"nonspherical",
"nonstandard",
"nonsteroidal",
"nonstick",
"nonstop",
"nonstructural",
"nonsubjective",
"nonsubmergible",
"nonsubmersible",
"nonsuppurative",
"nonsurgical",
"nonsweet",
"nonsyllabic",
"nonsymbiotic",
"nonsynchronous",
"nonsynthetic",
"nontaxable",
"nontechnical",
"nontelescopic",
"nontelescoping",
"nonterritorial",
"nonthermal",
"nontoxic",
"nontraditional",
"nontransferable",
"nonturbulent",
"nonuniform",
"nonunion",
"nonunionised",
"nonunionized",
"nonuple",
"nonvenomous",
"nonverbal",
"nonviable",
"nonviolent",
"nonviscid",
"nonvisual",
"nonvolatile",
"nonvoluntary",
"nonwashable",
"nonwoody",
"nordic",
"normal",
"norman",
"normative",
"normotensive",
"norse",
"north",
"northbound",
"northeast",
"northeasterly",
"northeastern",
"northeastward",
"northerly",
"northern",
"northernmost",
"northmost",
"northward",
"northwest",
"northwesterly",
"northwestern",
"northwestward",
"norwegian",
"nosed",
"noseless",
"nosey",
"nosocomial",
"nosohusial",
"nostalgic",
"nosy",
"notable",
"notched",
"noted",
"noteworthy",
"noticeable",
"noticed",
"notifiable",
"notional",
"notorious",
"nourished",
"nourishing",
"novel",
"noxious",
"nubbly",
"nubby",
"nubile",
"nuclear",
"nucleate",
"nucleated",
"nude",
"nugatory",
"null",
"nullified",
"numb",
"numberless",
"numbing",
"numerable",
"numeral",
"numerate",
"numeric",
"numerical",
"numerological",
"numerous",
"numidian",
"numinous",
"nuptial",
"nursed",
"nurtural",
"nurturant",
"nutbrown",
"nutlike",
"nutrient",
"nutritional",
"nutritionary",
"nutritious",
"nutritive",
"nuts",
"nutty",
"nymphomaniac",
"nymphomaniacal",
"oafish",
"oaken",
"oaten",
"obdurate",
"obedient",
"obese",
"objectionable",
"objective",
"oblanceolate",
"oblate",
"obligate",
"obligated",
"obligational",
"obligatory",
"obliged",
"obliging",
"oblique",
"obliterable",
"obliterate",
"obliterated",
"oblivious",
"oblong",
"obnoxious",
"obovate",
"obscene",
"obscure",
"obsequious",
"observable",
"observant",
"observational",
"observed",
"observing",
"obsessed",
"obsessional",
"obsessive",
"obsolescent",
"obsolete",
"obstetric",
"obstetrical",
"obstinate",
"obstreperous",
"obstructed",
"obstructive",
"obtainable",
"obtrusive",
"obtuse",
"obviating",
"obvious",
"occasional",
"occidental",
"occipital",
"occluded",
"occlusive",
"occult",
"occupational",
"occupied",
"occurrent",
"oceangoing",
"oceanic",
"ocellated",
"ocher",
"ochre",
"octagonal",
"octal",
"octangular",
"octogenarian",
"octosyllabic",
"octuple",
"ocular",
"oddish",
"odious",
"odoriferous",
"odorless",
"odorous",
"odourless",
"oecumenic",
"oecumenical",
"offbeat",
"offenceless",
"offended",
"offending",
"offenseless",
"offensive",
"offhand",
"offhanded",
"official",
"officious",
"offish",
"offshore",
"offside",
"offsides",
"offstage",
"ohmic",
"oiled",
"oily",
"okay",
"olden",
"older",
"oldish",
"oldline",
"oleaceous",
"oleaginous",
"oleophilic",
"oleophobic",
"olfactive",
"olfactory",
"oligarchic",
"oligarchical",
"olive",
"olivelike",
"olympian",
"olympic",
"omani",
"ominous",
"omissible",
"omissive",
"omnibus",
"omnidirectional",
"omnifarious",
"omnipotent",
"omnipresent",
"omniscient",
"omnivorous",
"oncologic",
"oncological",
"oncoming",
"oneiric",
"onerous",
"onetime",
"ongoing",
"online",
"only",
"onomastic",
"onomatopoeic",
"onomatopoeical",
"onomatopoetic",
"onshore",
"onside",
"onstage",
"ontogenetic",
"ontological",
"onymous",
"oozing",
"oozy",
"opalescent",
"opaline",
"opaque",
"open",
"opencast",
"opencut",
"opened",
"openhanded",
"openhearted",
"opening",
"openmouthed",
"operable",
"operant",
"operatic",
"operating",
"operational",
"operationalist",
"operative",
"operculate",
"operculated",
"operose",
"ophthalmic",
"opinionated",
"opinionative",
"opisthognathous",
"opponent",
"opportune",
"opportunist",
"opportunistic",
"opposable",
"opposed",
"opposing",
"opposite",
"oppositive",
"oppressed",
"oppressive",
"opprobrious",
"optative",
"optic",
"optical",
"optimal",
"optimistic",
"optimum",
"optional",
"opulent",
"oracular",
"oral",
"orange",
"orangish",
"oratorical",
"orbicular",
"orbiculate",
"orbital",
"orbitual",
"orchestral",
"orchestrated",
"ordained",
"ordered",
"orderly",
"ordinal",
"ordinary",
"organic",
"organicistic",
"organisational",
"organised",
"organismal",
"organismic",
"organizational",
"organized",
"orgiastic",
"oriental",
"orientated",
"orientating",
"oriented",
"orienting",
"original",
"originative",
"ornamental",
"ornate",
"ornery",
"ornithological",
"oropharyngeal",
"orotund",
"orphaned",
"orphic",
"orthodontic",
"orthodox",
"orthogonal",
"orthographic",
"orthomolecular",
"orthopaedic",
"orthopedic",
"orthopedical",
"orthoptic",
"orthostatic",
"orthotropous",
"orwellian",
"oscillating",
"oscillatory",
"oscine",
"oscitant",
"osmotic",
"osseous",
"ossicular",
"ossiculate",
"ossiferous",
"ossified",
"osteal",
"ostensible",
"ostensive",
"ostentatious",
"other",
"otherwise",
"otherworldly",
"otic",
"otiose",
"ototoxic",
"ottoman",
"outback",
"outboard",
"outbound",
"outbred",
"outcast",
"outcaste",
"outclassed",
"outdated",
"outdoor",
"outdoorsy",
"outer",
"outermost",
"outfitted",
"outflowing",
"outgoing",
"outlandish",
"outlaw",
"outlawed",
"outlined",
"outlying",
"outmoded",
"outmost",
"outraged",
"outrageous",
"outre",
"outrigged",
"outright",
"outside",
"outsize",
"outsized",
"outspoken",
"outspread",
"outstanding",
"outstretched",
"outward",
"oval",
"ovarian",
"ovate",
"over",
"overabundant",
"overactive",
"overage",
"overaged",
"overall",
"overambitious",
"overanxious",
"overarm",
"overawed",
"overbearing",
"overblown",
"overbold",
"overburdened",
"overbusy",
"overcareful",
"overcast",
"overcautious",
"overconfident",
"overcredulous",
"overcritical",
"overcurious",
"overdelicate",
"overdone",
"overdressed",
"overdue",
"overeager",
"overemotional",
"overexcited",
"overfamiliar",
"overfed",
"overflowing",
"overfond",
"overfull",
"overgenerous",
"overgreedy",
"overgrown",
"overhand",
"overhanded",
"overhasty",
"overhead",
"overheated",
"overindulgent",
"overjealous",
"overjoyed",
"overladen",
"overland",
"overlarge",
"overloaded",
"overlooked",
"overlooking",
"overlying",
"overmodest",
"overmuch",
"overnice",
"overnight",
"overpowering",
"overpriced",
"overprotective",
"overproud",
"overreaching",
"overrefined",
"overriding",
"overripe",
"oversea",
"overseas",
"oversensitive",
"overserious",
"oversewn",
"oversexed",
"overshot",
"oversize",
"oversized",
"oversolicitous",
"overstated",
"overstrung",
"overstuffed",
"oversubscribed",
"oversuspicious",
"overt",
"overturned",
"overvaliant",
"overweening",
"overweight",
"overwhelming",
"overwrought",
"overzealous",
"oviform",
"ovine",
"oviparous",
"ovoid",
"ovoviviparous",
"ovular",
"owing",
"owlish",
"owned",
"ownerless",
"oxalic",
"oxidative",
"oxidised",
"oxidizable",
"oxidized",
"oxonian",
"pachydermal",
"pachydermatous",
"pachydermic",
"pachydermous",
"pacific",
"pacifist",
"pacifistic",
"packable",
"packaged",
"packed",
"padded",
"paederastic",
"paediatric",
"pagan",
"paid",
"pained",
"painful",
"painless",
"painstaking",
"paintable",
"painted",
"painterly",
"paired",
"pakistani",
"palaeolithic",
"palatable",
"palatal",
"palatalised",
"palatalized",
"palatial",
"palatine",
"palatoglossal",
"pale",
"paleocortical",
"paleolithic",
"paleontological",
"paleozoic",
"palestinian",
"palingenetic",
"palish",
"palladian",
"palliative",
"pallid",
"pally",
"palmar",
"palmate",
"palmatifid",
"palmlike",
"palmy",
"palpable",
"palpatory",
"palpebrate",
"palpitant",
"palpitating",
"palsied",
"paltry",
"pampering",
"panamanian",
"pancreatic",
"pandemic",
"pandurate",
"panduriform",
"panegyric",
"panegyrical",
"paneled",
"panhellenic",
"panicked",
"panicky",
"panicled",
"paniculate",
"panoplied",
"panoptic",
"panoptical",
"panoramic",
"pantalooned",
"pantheist",
"pantheistic",
"pantropic",
"pantropical",
"papal",
"paperback",
"paperbacked",
"paperlike",
"papery",
"papillary",
"papillate",
"papilliform",
"papillose",
"papist",
"papistic",
"papistical",
"pappose",
"papuan",
"parabolic",
"parabolical",
"paraboloidal",
"paradigmatic",
"paradisaic",
"paradisaical",
"paradisal",
"paradisiac",
"paradisiacal",
"paradoxical",
"paraguayan",
"parallel",
"paralytic",
"paralytical",
"paralyzed",
"paramagnetic",
"paramedical",
"parametric",
"paramilitary",
"paramount",
"paranasal",
"paranoid",
"paranormal",
"paraphrastic",
"paraplegic",
"parasitic",
"parasitical",
"parasiticidal",
"parasympathetic",
"parched",
"pardonable",
"parental",
"parented",
"parenteral",
"parenthetic",
"parenthetical",
"parentless",
"pareve",
"parheliacal",
"parhelic",
"parietal",
"paripinnate",
"parisian",
"parked",
"parky",
"parliamentary",
"parlous",
"parochial",
"paroicous",
"parotid",
"parous",
"paroxysmal",
"parrotlike",
"parsimonious",
"parted",
"parthenogenetic",
"parthian",
"partial",
"partible",
"participating",
"participatory",
"participial",
"particolored",
"particoloured",
"particular",
"particularised",
"particularistic",
"particularized",
"particulate",
"partisan",
"partitive",
"partizan",
"parturient",
"parve",
"parvenu",
"parvenue",
"paschal",
"pass",
"passable",
"passant",
"passe",
"passee",
"passerine",
"passing",
"passionate",
"passionless",
"passive",
"past",
"pasted",
"pastel",
"pastelike",
"pasteurian",
"pasteurised",
"pasteurized",
"pastoral",
"pasty",
"patched",
"patchy",
"patellar",
"patelliform",
"patent",
"patented",
"paternal",
"paternalistic",
"pathetic",
"pathless",
"pathogenic",
"pathologic",
"pathological",
"patient",
"patriarchal",
"patriarchic",
"patricentric",
"patrician",
"patrilineal",
"patrilinear",
"patrimonial",
"patriotic",
"patristic",
"patristical",
"patronised",
"patronising",
"patronized",
"patronizing",
"patronless",
"patronymic",
"patterned",
"pauline",
"paunchy",
"paved",
"pavlovian",
"pawky",
"payable",
"paying",
"peaceable",
"peaceful",
"peacekeeping",
"peachy",
"peaked",
"peaky",
"peanut",
"pearlescent",
"pearly",
"peaty",
"pebbly",
"peccable",
"peccant",
"peckish",
"pectic",
"pectinate",
"pectineal",
"pectoral",
"peculiar",
"pecuniary",
"pedagogic",
"pedagogical",
"pedal",
"pedantic",
"pedate",
"pederastic",
"pedestrian",
"pediatric",
"pedigree",
"pedigreed",
"pedunculate",
"peeled",
"peerless",
"peeved",
"peevish",
"pejorative",
"pelagic",
"pelecypod",
"pelecypodous",
"pellucid",
"peloponnesian",
"peltate",
"pelvic",
"pemphigous",
"penal",
"penciled",
"pencilled",
"pendant",
"pendent",
"pending",
"pendulous",
"penetrable",
"penetrating",
"penetrative",
"penial",
"penile",
"peninsular",
"penitent",
"penitential",
"penitentiary",
"pennate",
"penniless",
"pensionable",
"pensive",
"pent",
"pentagonal",
"pentamerous",
"pentangular",
"pentasyllabic",
"pentatonic",
"pentavalent",
"pentecostal",
"penultimate",
"penumbral",
"penurious",
"peopled",
"peppery",
"peppy",
"peptic",
"perambulating",
"perceivable",
"perceived",
"perceptible",
"perceptive",
"perceptual",
"percipient",
"percussive",
"percutaneous",
"perdurable",
"peregrine",
"peremptory",
"perennial",
"perfect",
"perfected",
"perfectible",
"perfervid",
"perfidious",
"perfoliate",
"perforate",
"perforated",
"perfumed",
"perfunctory",
"perianal",
"pericardiac",
"pericardial",
"perigonal",
"perilous",
"perinasal",
"perinatal",
"perineal",
"periodic",
"periodical",
"periodontal",
"periodontic",
"peripatetic",
"peripheral",
"periphrastic",
"peripteral",
"perirhinal",
"perishable",
"peristylar",
"perithelial",
"peritoneal",
"peritrichous",
"periwigged",
"perky",
"permanent",
"permeable",
"permeant",
"permeating",
"permeative",
"permed",
"permissible",
"permissive",
"permutable",
"pernicious",
"pernickety",
"peroneal",
"perpendicular",
"perpetual",
"perplexed",
"perplexing",
"persevering",
"persian",
"persistent",
"persisting",
"persnickety",
"personable",
"personal",
"personalised",
"personalized",
"perspicacious",
"perspicuous",
"persuadable",
"persuasible",
"persuasive",
"pert",
"pertinacious",
"pertinent",
"perturbed",
"perturbing",
"peruked",
"peruvian",
"pervasive",
"perverse",
"perversive",
"perverted",
"pervious",
"pesky",
"pessimal",
"pessimistic",
"pessimum",
"pestered",
"pestering",
"pestiferous",
"pestilent",
"pestilential",
"petaled",
"petalled",
"petalless",
"petallike",
"petaloid",
"petalous",
"petite",
"petitionary",
"petrifying",
"petrous",
"petticoated",
"pettish",
"petty",
"petulant",
"phagocytic",
"phalangeal",
"phallic",
"phantasmagoric",
"phantasmal",
"phantom",
"pharaonic",
"pharisaic",
"pharisaical",
"pharmaceutic",
"pharmaceutical",
"pharmacologic",
"pharmacological",
"pharyngeal",
"phenomenal",
"phenotypic",
"phenotypical",
"philanthropic",
"philatelic",
"philatelical",
"philharmonic",
"philhellene",
"philhellenic",
"philippine",
"philistine",
"philological",
"philosophic",
"philosophical",
"phlegmatic",
"phlegmatical",
"phlegmy",
"phobic",
"phocine",
"phoenician",
"phonemic",
"phonetic",
"phoney",
"phonic",
"phonogramic",
"phonologic",
"phonological",
"phony",
"phosphorescent",
"phosphoric",
"phosphorous",
"photic",
"photochemical",
"photoconductive",
"photoelectric",
"photoelectrical",
"photoemissive",
"photogenic",
"photographic",
"photomechanical",
"photometric",
"photometrical",
"photosensitive",
"photosynthetic",
"photovoltaic",
"phrasal",
"phreatic",
"phrenetic",
"phrenic",
"phrenological",
"phyletic",
"phylliform",
"phyllodial",
"phylogenetic",
"physical",
"physicochemical",
"physiologic",
"physiological",
"phytophagic",
"phytophagous",
"phytophilous",
"piagetian",
"pianissimo",
"pianistic",
"piano",
"picaresque",
"picayune",
"pickled",
"picky",
"pictographic",
"pictorial",
"pictural",
"pictured",
"picturesque",
"piddling",
"piebald",
"piecemeal",
"pied",
"pierced",
"piercing",
"pietistic",
"pietistical",
"piezoelectric",
"piffling",
"piggish",
"piggy",
"pigheaded",
"pilar",
"pilary",
"pillaged",
"pillared",
"pilose",
"pilosebaceous",
"pilotless",
"pilous",
"pimpled",
"pimply",
"pinchbeck",
"pinched",
"pineal",
"pinioned",
"pink",
"pinkish",
"pinnate",
"pinnated",
"pinnatifid",
"pinnatisect",
"pinstriped",
"pious",
"piquant",
"piratical",
"piscatorial",
"piscatory",
"piscine",
"piscivorous",
"pissed",
"pistillate",
"pitched",
"pitchy",
"piteous",
"pithy",
"pitiable",
"pitiful",
"pitiless",
"pitted",
"pituitary",
"pivotal",
"pixilated",
"pizzicato",
"placable",
"placating",
"placative",
"placatory",
"placeable",
"placed",
"placental",
"placid",
"placoid",
"plagiarised",
"plagiaristic",
"plagiarized",
"plagioclastic",
"plaguey",
"plaguy",
"plain",
"plainspoken",
"plaintive",
"planar",
"planate",
"plane",
"planetal",
"planetary",
"plangent",
"planktonic",
"planless",
"planned",
"planoconcave",
"planoconvex",
"planographic",
"plantal",
"plantar",
"planted",
"plantigrade",
"plastered",
"plastic",
"platelike",
"platitudinal",
"platitudinous",
"platonic",
"platonistic",
"platyrhine",
"platyrhinian",
"platyrrhine",
"platyrrhinian",
"platyrrhinic",
"plausible",
"plausive",
"playable",
"played",
"playful",
"pleading",
"pleasant",
"pleased",
"pleasing",
"pleasurable",
"plebeian",
"pledged",
"plenary",
"plenteous",
"plentiful",
"pleochroic",
"pleomorphic",
"pleonastic",
"plethoric",
"pleural",
"pleurocarpous",
"pliable",
"pliant",
"plodding",
"plotted",
"ploughed",
"plowed",
"plucked",
"plucky",
"plugged",
"plumaged",
"plumate",
"plumb",
"plumbable",
"plumbaginaceous",
"plumbic",
"plumbous",
"plumed",
"plumelike",
"plumlike",
"plummy",
"plumose",
"plump",
"plumping",
"plumy",
"plundered",
"plundering",
"pluperfect",
"plural",
"pluralistic",
"plus",
"plush",
"plushy",
"plutocratic",
"plutocratical",
"plutonian",
"plutonic",
"pneumatic",
"pneumococcal",
"pneumogastric",
"pneumonic",
"poached",
"pocked",
"pocketable",
"pockmarked",
"podgy",
"podlike",
"poetic",
"poetical",
"poignant",
"poikilothermic",
"poikilothermous",
"pointed",
"pointillist",
"pointillistic",
"pointless",
"poised",
"poisonous",
"pokey",
"poky",
"polar",
"polarographic",
"polemic",
"polemical",
"polemoniaceous",
"polish",
"polished",
"polite",
"politic",
"political",
"polluted",
"pollyannaish",
"poltroon",
"polyandrous",
"polyatomic",
"polychromatic",
"polychrome",
"polychromic",
"polycrystalline",
"polydactyl",
"polydactylous",
"polyestrous",
"polygamous",
"polygenic",
"polyglot",
"polygonal",
"polygynous",
"polyhedral",
"polymeric",
"polymorphemic",
"polymorphic",
"polymorphous",
"polynesian",
"polynomial",
"polyoestrous",
"polyoicous",
"polypetalous",
"polyphase",
"polyphonic",
"polyphonous",
"polyploid",
"polysemantic",
"polysemous",
"polysyllabic",
"polysynthetic",
"polytheistic",
"polytonal",
"polyunsaturated",
"polyvalent",
"pomaded",
"pompous",
"ponderable",
"pondering",
"ponderous",
"pontifical",
"poor",
"poorly",
"popeyed",
"popish",
"popliteal",
"popular",
"populated",
"populous",
"porcine",
"poriferous",
"pornographic",
"porose",
"porous",
"porphyritic",
"port",
"portable",
"portentous",
"porticoed",
"portly",
"portrayed",
"portuguese",
"posed",
"posh",
"positionable",
"positional",
"positioning",
"positive",
"positivist",
"positivistic",
"possessed",
"possessive",
"possible",
"postal",
"postbiblical",
"postdiluvian",
"postdoctoral",
"posted",
"posterior",
"postexilic",
"postganglionic",
"postglacial",
"postgraduate",
"posthumous",
"postictal",
"postindustrial",
"postmenopausal",
"postmeridian",
"postmillennial",
"postmodern",
"postmodernist",
"postmortal",
"postmortem",
"postnatal",
"postnuptial",
"postoperative",
"postpaid",
"postpartum",
"postpositive",
"postprandial",
"postulational",
"postural",
"postwar",
"potable",
"potbellied",
"potbound",
"potent",
"potential",
"potholed",
"potted",
"potty",
"pouched",
"pouchlike",
"pouring",
"powdered",
"powdery",
"powered",
"powerful",
"powerless",
"practicable",
"practical",
"practiced",
"practised",
"praetorial",
"praetorian",
"pragmatic",
"pragmatical",
"praiseful",
"praiseworthy",
"praising",
"prakritic",
"prandial",
"prankish",
"prayerful",
"preachy",
"preadolescent",
"preanal",
"precancerous",
"precarious",
"precast",
"precative",
"precatory",
"precautional",
"precautionary",
"precedent",
"precedented",
"precedential",
"preceding",
"precious",
"precipitant",
"precipitate",
"precipitating",
"precipitous",
"precise",
"preclinical",
"preclusive",
"precocial",
"precocious",
"precognitive",
"preconceived",
"preconcerted",
"preconditioned",
"precooked",
"precooled",
"precordial",
"precursory",
"predaceous",
"predacious",
"predatory",
"predestinarian",
"predestinate",
"predestined",
"predetermined",
"predicative",
"predictable",
"predictive",
"predigested",
"predisposed",
"predominant",
"predominate",
"preeminent",
"preemptive",
"preexistent",
"preexisting",
"prefab",
"prefaded",
"prefatorial",
"prefatory",
"prefectural",
"preferable",
"preferent",
"preferential",
"preferred",
"prefigurative",
"prefrontal",
"pregnant",
"prehensile",
"prehistoric",
"prehistorical",
"prejudiced",
"prejudicial",
"prejudicious",
"prelapsarian",
"preliminary",
"preliterate",
"premarital",
"premature",
"premedical",
"premeditated",
"premenopausal",
"premenstrual",
"premier",
"premiere",
"premium",
"premonitory",
"prenatal",
"prenominal",
"prenuptial",
"preoccupied",
"preoperative",
"prepackaged",
"prepacked",
"prepaid",
"preparative",
"preparatory",
"prepared",
"preponderant",
"preponderating",
"prepositional",
"prepossessing",
"preposterous",
"preprandial",
"prepubertal",
"prepubescent",
"prepupal",
"prerecorded",
"prerequisite",
"presbyopic",
"prescient",
"prescribed",
"prescription",
"prescriptive",
"present",
"presentable",
"presentational",
"preservable",
"preservative",
"preserved",
"preset",
"presidential",
"presocratic",
"pressed",
"pressing",
"pressor",
"prestigious",
"prestissimo",
"presto",
"presumable",
"presumptive",
"presumptuous",
"presymptomatic",
"preteen",
"pretend",
"pretended",
"pretentious",
"preternatural",
"pretorial",
"pretorian",
"pretty",
"prevailing",
"prevalent",
"prevenient",
"preventable",
"preventative",
"preventive",
"previous",
"prewar",
"priapic",
"priceless",
"pricey",
"prickly",
"pricy",
"prideful",
"priestlike",
"priestly",
"priggish",
"prim",
"prima",
"primaeval",
"primal",
"primary",
"prime",
"primed",
"primeval",
"primiparous",
"primitive",
"primo",
"primordial",
"princely",
"principal",
"principled",
"printable",
"prior",
"prismatic",
"prisonlike",
"prissy",
"pristine",
"private",
"privileged",
"privy",
"prize",
"prizewinning",
"proactive",
"probabilistic",
"probable",
"probationary",
"probative",
"probatory",
"probing",
"problematic",
"problematical",
"procaryotic",
"procedural",
"processed",
"processional",
"proclaimed",
"proconsular",
"procreative",
"procrustean",
"procumbent",
"procurable",
"prodigal",
"prodigious",
"prodromal",
"prodromic",
"productive",
"profanatory",
"profane",
"profaned",
"professed",
"professional",
"professorial",
"proficient",
"profitable",
"profitless",
"profligate",
"profound",
"profuse",
"progestational",
"prognathic",
"prognathous",
"prognostic",
"prognosticative",
"progressive",
"prohibited",
"prohibitive",
"prohibitory",
"proinflammatory",
"projected",
"projectile",
"projecting",
"prokaryotic",
"prolate",
"proletarian",
"prolific",
"prolix",
"prolonged",
"prolusory",
"prominent",
"promiscuous",
"promising",
"promissory",
"promotional",
"promotive",
"prompt",
"promulgated",
"prone",
"pronged",
"prongy",
"pronominal",
"pronounceable",
"pronounced",
"proof",
"proofed",
"propaedeutic",
"propagandist",
"propagandistic",
"propagative",
"propellant",
"propellent",
"propelling",
"proper",
"propertied",
"propertyless",
"prophetic",
"prophetical",
"prophylactic",
"propitiative",
"propitiatory",
"propitious",
"proportionable",
"proportional",
"proportionate",
"proprietary",
"proprioceptive",
"propulsive",
"prosaic",
"proscribed",
"prosodic",
"prospective",
"prospering",
"prosperous",
"prospicient",
"prostate",
"prostatic",
"prosthetic",
"prosthodontic",
"prostrate",
"prostyle",
"prosy",
"protanopic",
"protean",
"protected",
"protecting",
"protective",
"proteinaceous",
"proteolytic",
"proterozoic",
"protestant",
"proto",
"protogeometric",
"prototypal",
"prototypic",
"prototypical",
"protozoal",
"protozoan",
"protozoic",
"protozoological",
"protracted",
"protractible",
"protractile",
"protruding",
"protrusible",
"protrusile",
"protrusive",
"protuberant",
"proud",
"proustian",
"provable",
"proved",
"proven",
"provencal",
"proverbial",
"provident",
"providential",
"provincial",
"provisional",
"provisionary",
"provisory",
"provocative",
"provoked",
"provoking",
"prox",
"proximal",
"proximate",
"proximo",
"prudent",
"prudential",
"prudish",
"prurient",
"prussian",
"prying",
"pseudo",
"pseudonymous",
"pseudoprostyle",
"psychedelic",
"psychiatric",
"psychiatrical",
"psychic",
"psychical",
"psychoactive",
"psychoanalytic",
"psychogenetic",
"psychogenic",
"psychokinetic",
"psychological",
"psychometric",
"psychomotor",
"psychoneurotic",
"psychopathic",
"psychosexual",
"psychosomatic",
"psychotic",
"psychotropic",
"pteridological",
"ptolemaic",
"pubertal",
"puberulent",
"pubescent",
"pubic",
"public",
"publicised",
"publicized",
"publishable",
"published",
"pucka",
"puckish",
"puddingheaded",
"pudendal",
"pudgy",
"puerile",
"puerperal",
"puff",
"puffed",
"puffy",
"pugilistic",
"pugnacious",
"puissant",
"pukka",
"pulchritudinous",
"pulmonary",
"pulmonic",
"pulpy",
"pulseless",
"pulverised",
"pulverized",
"pumped",
"punctilious",
"punctual",
"puncturable",
"punctured",
"punctureless",
"pungent",
"punic",
"punishable",
"punished",
"punishing",
"punitive",
"punitory",
"punk",
"puny",
"pupal",
"pupillary",
"puppyish",
"puppylike",
"puranic",
"purblind",
"purchasable",
"pure",
"pureblood",
"pureblooded",
"purebred",
"purgative",
"purgatorial",
"purging",
"purifying",
"puritanic",
"puritanical",
"purple",
"purplish",
"purposeful",
"purposeless",
"purposive",
"pursuant",
"pursued",
"pursuing",
"pursy",
"purulent",
"pushful",
"pushy",
"pusillanimous",
"pussy",
"pustulate",
"putative",
"putdownable",
"putrefacient",
"putrefactive",
"putrefiable",
"putrescent",
"putrescible",
"putrid",
"puzzled",
"puzzling",
"pyaemic",
"pycnotic",
"pyemic",
"pyknic",
"pyknotic",
"pyloric",
"pyogenic",
"pyramidal",
"pyramidic",
"pyramidical",
"pyrectic",
"pyretic",
"pyrochemical",
"pyroelectric",
"pyroelectrical",
"pyrogallic",
"pyrogenetic",
"pyrogenic",
"pyrogenous",
"pyrographic",
"pyroligneous",
"pyrolignic",
"pyrolytic",
"pyrotechnic",
"pyrotechnical",
"pyrrhic",
"pythagorean",
"qabalistic",
"qatari",
"quack",
"quadrangular",
"quadraphonic",
"quadrasonic",
"quadrate",
"quadratic",
"quadrilateral",
"quadrillionth",
"quadripartite",
"quadriphonic",
"quadrisonic",
"quadruped",
"quadrupedal",
"quadruple",
"quadruplex",
"quadruplicate",
"quaggy",
"quaint",
"qualified",
"qualitative",
"quality",
"quantal",
"quantifiable",
"quantitative",
"quantized",
"quarantined",
"quarrelsome",
"quartan",
"quarterly",
"quartzose",
"quasi",
"quaternary",
"quaternate",
"quavering",
"queasy",
"quebecois",
"quechuan",
"queenlike",
"queenly",
"queer",
"quelled",
"quenched",
"quenchless",
"querulous",
"questionable",
"questioning",
"quick",
"quickset",
"quicksilver",
"quiescent",
"quiet",
"quilted",
"quincentenary",
"quincentennial",
"quinquefoliate",
"quintessential",
"quintillionth",
"quintuple",
"quirky",
"quits",
"quixotic",
"quizzical",
"quondam",
"quotable",
"quotidian",
"rabbinic",
"rabbinical",
"rabelaisian",
"rabid",
"racemose",
"rachitic",
"racial",
"racist",
"rackety",
"racking",
"racy",
"raddled",
"radial",
"radiant",
"radiate",
"radiating",
"radical",
"radio",
"radioactive",
"radiographic",
"radiological",
"radiolucent",
"radiopaque",
"radiophonic",
"radiosensitive",
"radiotelephonic",
"raffish",
"raftered",
"ragged",
"raging",
"raiding",
"raimentless",
"raining",
"rainless",
"rainproof",
"rainy",
"raisable",
"raiseable",
"raised",
"raising",
"rakish",
"rallentando",
"rallying",
"ramate",
"rambling",
"rambunctious",
"ramose",
"ramous",
"rampageous",
"rampant",
"ramshackle",
"rancid",
"rancorous",
"random",
"randomised",
"randomized",
"randy",
"ranging",
"rangy",
"rank",
"ranked",
"ranking",
"ransacked",
"ransomed",
"rapacious",
"raped",
"rapid",
"rapt",
"raptorial",
"rapturous",
"rare",
"rarefied",
"rarified",
"raring",
"rascally",
"rash",
"rasping",
"raspy",
"rastafarian",
"ratable",
"rateable",
"ratified",
"ratiocinative",
"rational",
"rationalist",
"rationalistic",
"rationed",
"ratlike",
"rattlebrained",
"rattled",
"rattlepated",
"rattling",
"ratty",
"raucous",
"raunchy",
"ravaged",
"ravaging",
"ravening",
"ravenous",
"ravishing",
"rawboned",
"rayless",
"razed",
"razorback",
"reachable",
"reactionary",
"reactionist",
"reactive",
"readable",
"ready",
"real",
"realised",
"realistic",
"realizable",
"realized",
"reanimated",
"rear",
"rearing",
"rearmost",
"rearward",
"reasonable",
"reasoned",
"reasoning",
"reasonless",
"reassured",
"reassuring",
"rebarbative",
"rebellious",
"reborn",
"recalcitrant",
"receding",
"receivable",
"received",
"recent",
"receptive",
"recessed",
"recessional",
"recessionary",
"recessive",
"rechargeable",
"recherche",
"reciprocal",
"reciprocative",
"reciprocatory",
"reckless",
"reclaimable",
"reclaimed",
"recluse",
"reclusive",
"recognisable",
"recognised",
"recognizable",
"recognized",
"recoilless",
"recollective",
"recombinant",
"reconcilable",
"reconciled",
"reconciling",
"recondite",
"reconstructed",
"reconstructive",
"recorded",
"recoverable",
"recovered",
"recovering",
"recreant",
"recreational",
"recriminative",
"recriminatory",
"recrudescent",
"rectal",
"rectangular",
"rectifiable",
"rectified",
"rectilineal",
"rectilinear",
"rectosigmoid",
"recumbent",
"recuperative",
"recurrent",
"recurring",
"recursive",
"recurvate",
"recurved",
"recusant",
"recyclable",
"redbrick",
"reddened",
"reddish",
"redeemable",
"redeemed",
"redeeming",
"redemptional",
"redemptive",
"redemptory",
"redheaded",
"redistributed",
"redolent",
"redoubled",
"redoubtable",
"reduced",
"reducible",
"reductionist",
"reductive",
"redundant",
"redux",
"reechoing",
"reedlike",
"reedy",
"reefy",
"reeking",
"reentrant",
"referable",
"referenced",
"referent",
"referential",
"refined",
"reflected",
"reflecting",
"reflective",
"reflex",
"reflexed",
"reflexive",
"reformable",
"reformative",
"reformatory",
"reformed",
"reformist",
"refractile",
"refractive",
"refractory",
"refreshed",
"refreshful",
"refreshing",
"refrigerant",
"refrigerated",
"refrigerating",
"refulgent",
"refutable",
"regal",
"regardant",
"regardful",
"regardless",
"regenerate",
"regenerating",
"regent",
"regimental",
"regimented",
"regional",
"registered",
"regnant",
"regressive",
"regretful",
"regrettable",
"regular",
"regulated",
"regulation",
"regulative",
"regulatory",
"rehabilitative",
"reigning",
"reincarnate",
"reinforced",
"reinvigorated",
"reiterative",
"rejected",
"rejective",
"rejoicing",
"related",
"relational",
"relative",
"relativistic",
"relaxant",
"relaxed",
"relaxing",
"releasing",
"relentless",
"relevant",
"reliable",
"reliant",
"relieved",
"religious",
"relinquished",
"relocated",
"reluctant",
"remaining",
"remarkable",
"rembrandtesque",
"remediable",
"remedial",
"remindful",
"reminiscent",
"remiss",
"remittent",
"remorseful",
"remorseless",
"remote",
"removable",
"removed",
"remunerated",
"remunerative",
"renal",
"renascent",
"rending",
"renegade",
"renewable",
"renewed",
"renewing",
"reniform",
"renowned",
"rentable",
"rental",
"renunciant",
"renunciative",
"reorganised",
"reorganized",
"repand",
"reparable",
"repayable",
"repeatable",
"repeated",
"repellant",
"repellent",
"repelling",
"repentant",
"repetitious",
"repetitive",
"replaceable",
"replete",
"reportable",
"reported",
"reposeful",
"reprehensible",
"representable",
"representative",
"represented",
"repressed",
"repressing",
"repressive",
"reproachful",
"reprobate",
"reproducible",
"reproductive",
"reproving",
"reptilian",
"republican",
"repudiative",
"repugnant",
"repulsive",
"reputable",
"requested",
"required",
"requisite",
"rescindable",
"rescued",
"resentful",
"reserved",
"resettled",
"resident",
"residential",
"residual",
"residuary",
"resilient",
"resinated",
"resinlike",
"resinous",
"resiny",
"resistant",
"resistible",
"resistive",
"resistless",
"resolute",
"resolvable",
"resolved",
"resonant",
"resonating",
"resounding",
"resourceful",
"resourceless",
"respectable",
"respected",
"respectful",
"respective",
"respiratory",
"resplendent",
"respondent",
"responsible",
"responsive",
"rested",
"restful",
"restive",
"restless",
"restorative",
"restrained",
"restricted",
"restricting",
"restrictive",
"resultant",
"resupine",
"resurgent",
"resuscitated",
"retained",
"retaliative",
"retaliatory",
"retarded",
"retentive",
"reticent",
"reticular",
"reticulate",
"retinal",
"retired",
"retiring",
"retractable",
"retracted",
"retractile",
"retral",
"retributive",
"retributory",
"retrievable",
"retro",
"retroactive",
"retroflex",
"retroflexed",
"retrograde",
"retrogressive",
"retrorse",
"retrospective",
"retrousse",
"returnable",
"returning",
"reusable",
"revealing",
"revelatory",
"revenant",
"revengeful",
"reverberant",
"reverberating",
"reverberative",
"revered",
"reverend",
"reverent",
"reverential",
"reverse",
"reversed",
"reversible",
"reversionary",
"reversive",
"revertible",
"reverting",
"revised",
"revitalised",
"revitalising",
"revitalized",
"revitalizing",
"revivalistic",
"revived",
"reviving",
"revocable",
"revokable",
"revolting",
"revolutionary",
"revolved",
"rewardful",
"rewarding",
"rhapsodic",
"rhenish",
"rheologic",
"rheological",
"rhetorical",
"rheumatic",
"rheumatoid",
"rheumy",
"rhinal",
"rhizoidal",
"rhizomatous",
"rhodesian",
"rhombic",
"rhombohedral",
"rhomboid",
"rhomboidal",
"rhymed",
"rhymeless",
"rhyming",
"rhythmic",
"rhythmical",
"riant",
"ribald",
"ribbed",
"ribbonlike",
"ribbony",
"ribless",
"riblike",
"rich",
"rickettsial",
"rickety",
"riddled",
"ridged",
"ridiculous",
"riemannian",
"rife",
"rifled",
"rigged",
"right",
"righteous",
"rightful",
"rightish",
"rightist",
"rightmost",
"rigid",
"rigorous",
"riled",
"rimed",
"rimeless",
"riming",
"rimless",
"rimmed",
"rimose",
"rimy",
"ringed",
"ringleted",
"ringlike",
"riotous",
"riparian",
"ripe",
"ripened",
"ripped",
"ripping",
"rippled",
"risen",
"risible",
"rising",
"riskless",
"risky",
"risque",
"ritardando",
"ritenuto",
"ritual",
"ritualistic",
"ritzy",
"rivalrous",
"riveting",
"roadless",
"roan",
"roaring",
"roast",
"roasted",
"robed",
"robotic",
"robotlike",
"robust",
"robustious",
"rockbound",
"rocklike",
"rocky",
"rococo",
"rodlike",
"roguish",
"roiled",
"roiling",
"roily",
"rolled",
"rollicking",
"rolling",
"romaic",
"roman",
"romance",
"romani",
"romanian",
"romanic",
"romanist",
"romansh",
"romantic",
"romanticist",
"romanticistic",
"romany",
"romish",
"roofed",
"roofless",
"roomy",
"rooseveltian",
"rootbound",
"rooted",
"rootless",
"ropey",
"ropy",
"rosaceous",
"rose",
"roseate",
"rosicrucian",
"rostrate",
"rosy",
"rotary",
"rotatable",
"rotated",
"rotational",
"rotatory",
"rotted",
"rotten",
"rotund",
"rouged",
"rough",
"roughdried",
"roughened",
"roughhewn",
"roughish",
"roughshod",
"roumanian",
"round",
"roundabout",
"rounded",
"roundheaded",
"roundish",
"rousing",
"rousseauan",
"routine",
"roving",
"rowdy",
"royal",
"ruandan",
"rubber",
"rubberlike",
"rubbery",
"rubbishy",
"rubicund",
"ruby",
"rudderless",
"ruddy",
"rude",
"rudimentary",
"rueful",
"ruffianly",
"ruffled",
"rugged",
"rugose",
"ruined",
"ruinous",
"ruled",
"ruling",
"ruly",
"rumanian",
"rumansh",
"rumbling",
"rumbustious",
"ruminant",
"ruminative",
"rummy",
"rumpled",
"runaway",
"runcinate",
"runic",
"running",
"runny",
"runproof",
"runty",
"rupestral",
"rupicolous",
"rural",
"ruritanian",
"rush",
"rushed",
"rushlike",
"rushy",
"russet",
"russian",
"rust",
"rusted",
"rustic",
"rustless",
"rustling",
"rustproof",
"rustproofed",
"rusty",
"ruthful",
"ruthless",
"rutted",
"ruttish",
"rutty",
"rwandan",
"sabahan",
"sabbatarian",
"sabbatic",
"sabbatical",
"sabertoothed",
"sabine",
"sable",
"saccadic",
"saccharine",
"sacculate",
"sacculated",
"sacerdotal",
"sacked",
"saclike",
"sacral",
"sacramental",
"sacred",
"sacrificeable",
"sacrificial",
"sacrilegious",
"sacrosanct",
"saddled",
"sadducean",
"sadistic",
"sadomasochistic",
"safe",
"sagacious",
"sage",
"sagging",
"sagittal",
"sagittate",
"sagittiform",
"saharan",
"said",
"sainted",
"saintlike",
"saintly",
"salable",
"salacious",
"salamandriform",
"salaried",
"saleable",
"salient",
"salientian",
"saliferous",
"saline",
"salivary",
"sallow",
"salmon",
"salt",
"salted",
"saltish",
"saltlike",
"salty",
"salubrious",
"salutary",
"salvadoran",
"salvadorean",
"salvageable",
"salverform",
"salvific",
"salving",
"same",
"samoan",
"sanative",
"sanctified",
"sanctimonious",
"sanctionative",
"sanctioned",
"sanctioning",
"sandaled",
"sandalled",
"sandlike",
"sandpapery",
"sandy",
"sane",
"sanguinary",
"sanguine",
"sanguineous",
"sanious",
"sanitary",
"sanitised",
"sanitized",
"sapid",
"sapiens",
"sapient",
"sapiential",
"sapless",
"saponaceous",
"saponified",
"saporous",
"sapphic",
"sapphire",
"sapphirine",
"sappy",
"saprobic",
"saprophagous",
"saprophytic",
"saprozoic",
"sarawakian",
"sarcastic",
"sarcoid",
"sarcolemmal",
"sarcolemmic",
"sarcolemnous",
"sarcosomal",
"sardinian",
"sardonic",
"sartorial",
"sassy",
"satanic",
"satellite",
"satiable",
"satiate",
"satiated",
"satiny",
"satiric",
"satirical",
"satisfactory",
"satisfiable",
"satisfied",
"satisfying",
"saturated",
"saturnine",
"satyric",
"satyrical",
"saucy",
"saudi",
"saurian",
"saute",
"sauteed",
"savage",
"saved",
"saving",
"savorless",
"savory",
"savourless",
"savoury",
"saxatile",
"saxicoline",
"saxicolous",
"saxon",
"scabby",
"scabrous",
"scalable",
"scalar",
"scaled",
"scaleless",
"scalelike",
"scalene",
"scaley",
"scalic",
"scalloped",
"scaly",
"scandalous",
"scandent",
"scandinavian",
"scant",
"scanty",
"scaphoid",
"scapose",
"scapular",
"scapulohumeral",
"scarce",
"scarecrowish",
"scared",
"scarlet",
"scarred",
"scary",
"scathing",
"scatological",
"scatterbrained",
"scattered",
"scattershot",
"scatty",
"scenic",
"scented",
"scentless",
"sceptered",
"sceptical",
"sceptred",
"scheduled",
"schematic",
"scheming",
"schismatic",
"schismatical",
"schizoid",
"schizophrenic",
"schmaltzy",
"schmalzy",
"scholarly",
"scholastic",
"schoolboyish",
"schoolgirlish",
"schoolwide",
"sciatic",
"scientific",
"scintillant",
"scintillating",
"sciolistic",
"sclerosed",
"sclerotic",
"scopal",
"scorbutic",
"scorched",
"scorching",
"scoreless",
"scorned",
"scornful",
"scotch",
"scotomatous",
"scots",
"scottish",
"scoundrelly",
"scoured",
"scowling",
"scrabbly",
"scraggly",
"scraggy",
"scrambled",
"scrappy",
"scratchy",
"scrawny",
"screaky",
"screaming",
"screechy",
"screwball",
"screwy",
"scrimpy",
"scrimy",
"scripted",
"scriptural",
"scrivened",
"scrofulous",
"scrotal",
"scrub",
"scrubbed",
"scrubby",
"scruffy",
"scrumptious",
"scrupulous",
"sculpted",
"sculptural",
"sculptured",
"sculpturesque",
"scummy",
"scurfy",
"scurrilous",
"scurrying",
"scurvy",
"scythian",
"seaborne",
"seafaring",
"seagirt",
"seagoing",
"sealed",
"seamanlike",
"seamanly",
"seamed",
"seamless",
"seamy",
"sear",
"searching",
"seared",
"searing",
"seasick",
"seasonable",
"seasonal",
"seasoned",
"seated",
"seaward",
"seaworthy",
"sebaceous",
"secluded",
"second",
"secondary",
"secondhand",
"secret",
"secretarial",
"secretive",
"secretory",
"sectarian",
"sectional",
"sectioned",
"sectorial",
"secular",
"secure",
"sedate",
"sedative",
"sedentary",
"sedgelike",
"sedgy",
"sedimentary",
"seditious",
"seductive",
"sedulous",
"seeable",
"seeded",
"seedless",
"seedy",
"seeing",
"seeming",
"seemly",
"seeping",
"seething",
"segmental",
"segmented",
"segregated",
"seismal",
"seismic",
"seismologic",
"seismological",
"select",
"selected",
"selective",
"self",
"selfish",
"selfless",
"selfsame",
"seljuk",
"sellable",
"semantic",
"semestral",
"semestrial",
"semiabstract",
"semiannual",
"semiaquatic",
"semiarid",
"semiautomatic",
"semicentenary",
"semicentennial",
"semicircular",
"semicomatose",
"semiconducting",
"semiconductive",
"semiconscious",
"semidark",
"semidetached",
"semiempirical",
"semiformal",
"semihard",
"semiliquid",
"semiliterate",
"semilunar",
"semimonthly",
"seminal",
"seminiferous",
"seminude",
"semiofficial",
"semiopaque",
"semiotic",
"semiotical",
"semiparasitic",
"semipermanent",
"semipermeable",
"semipolitical",
"semiprecious",
"semiprivate",
"semipublic",
"semirigid",
"semiskilled",
"semisoft",
"semisolid",
"semisweet",
"semisynthetic",
"semite",
"semiterrestrial",
"semitic",
"semitransparent",
"semitropic",
"semitropical",
"semiweekly",
"sempiternal",
"senatorial",
"senecan",
"senegalese",
"senescent",
"senile",
"senior",
"sensate",
"sensational",
"sensed",
"senseless",
"sensible",
"sensitised",
"sensitising",
"sensitive",
"sensitized",
"sensitizing",
"sensorial",
"sensorimotor",
"sensorineural",
"sensory",
"sensual",
"sensuous",
"sent",
"sentential",
"sententious",
"sentient",
"sentimental",
"sepaline",
"sepaloid",
"separable",
"separate",
"separated",
"separatist",
"separative",
"septal",
"septate",
"septic",
"septicemic",
"septrional",
"septuple",
"sepulchral",
"sequent",
"sequential",
"sequestered",
"sequined",
"seraphic",
"seraphical",
"serbian",
"sere",
"serendipitous",
"serene",
"serflike",
"serial",
"sericeous",
"sericultural",
"seriocomic",
"seriocomical",
"serious",
"serologic",
"serological",
"serous",
"serpentine",
"serrate",
"serrated",
"serried",
"serrulate",
"serviceable",
"servile",
"servo",
"servomechanical",
"sesquipedalian",
"sessile",
"setaceous",
"setose",
"settled",
"seven",
"sevenfold",
"seventeen",
"seventeenth",
"seventh",
"seventieth",
"seventy",
"severable",
"several",
"severe",
"severed",
"sewed",
"sewn",
"sexagenarian",
"sexagesimal",
"sexed",
"sexist",
"sexless",
"sextuple",
"sexual",
"sexy",
"seychellois",
"shabby",
"shackled",
"shaded",
"shadowed",
"shadowy",
"shady",
"shagged",
"shaggy",
"shakable",
"shakeable",
"shakedown",
"shaken",
"shakespearean",
"shakespearian",
"shaky",
"shallow",
"sham",
"shamanist",
"shamanistic",
"shambolic",
"shamed",
"shamefaced",
"shameful",
"shameless",
"shaped",
"shapeless",
"shapely",
"shaping",
"shared",
"sharing",
"sharp",
"sharpened",
"shattered",
"shattering",
"shatterproof",
"shaved",
"shaven",
"shavian",
"sheared",
"sheathed",
"shed",
"sheeny",
"sheepish",
"sheeplike",
"sheer",
"sheetlike",
"shelflike",
"shelfy",
"shelled",
"shellproof",
"sheltered",
"shelvy",
"shielded",
"shifting",
"shiftless",
"shifty",
"shimmery",
"shingly",
"shining",
"shinto",
"shintoist",
"shintoistic",
"shiny",
"shipboard",
"shipshape",
"shirty",
"shitless",
"shitty",
"shivering",
"shivery",
"shoaly",
"shockable",
"shocked",
"shocking",
"shod",
"shodden",
"shoddy",
"shoed",
"shoeless",
"shona",
"shopsoiled",
"shopworn",
"shoreward",
"shorn",
"short",
"shortened",
"shorthand",
"shortish",
"shortsighted",
"shot",
"shouldered",
"shouted",
"showery",
"showy",
"shredded",
"shrewd",
"shrewish",
"shrieked",
"shrill",
"shrimpy",
"shrinkable",
"shriveled",
"shrivelled",
"shrubby",
"shrunken",
"shuddering",
"shuddery",
"shuha",
"shut",
"shuttered",
"siamese",
"siberian",
"sibilant",
"sibyllic",
"sibylline",
"sicilian",
"sick",
"sickening",
"sickish",
"sickly",
"side",
"sidearm",
"sidelong",
"sidereal",
"sidesplitting",
"sideways",
"sighted",
"sightless",
"sightly",
"sigmoid",
"sigmoidal",
"sign",
"signal",
"signed",
"significant",
"significative",
"sikh",
"silenced",
"silent",
"siliceous",
"silicious",
"silken",
"silklike",
"silky",
"silly",
"silty",
"silvan",
"silver",
"silverish",
"silvern",
"silvery",
"simian",
"similar",
"simple",
"simplex",
"simplistic",
"simulated",
"simultaneous",
"sincere",
"sinewy",
"sinful",
"singable",
"singaporean",
"singhalese",
"singing",
"single",
"singsong",
"singular",
"sinhala",
"sinhalese",
"sinister",
"sinistral",
"sinistrorsal",
"sinistrorse",
"sinitic",
"sinkable",
"sinless",
"sinning",
"sintered",
"sinuate",
"sinuous",
"sinusoidal",
"siouan",
"sissified",
"sissy",
"sissyish",
"sisterlike",
"sisterly",
"sisyphean",
"sitting",
"situated",
"sixfold",
"sixpenny",
"sixteen",
"sixteenth",
"sixth",
"sixtieth",
"sixty",
"sizable",
"size",
"sizeable",
"sized",
"sizzling",
"skanky",
"skeletal",
"skeptical",
"sketchy",
"skew",
"skewed",
"skilful",
"skilled",
"skillful",
"skim",
"skimmed",
"skimpy",
"skinless",
"skinned",
"skinnerian",
"skinny",
"skint",
"skintight",
"skirting",
"skittish",
"skyward",
"slack",
"slain",
"slaked",
"slanderous",
"slangy",
"slanted",
"slanting",
"slapdash",
"slaphappy",
"slapstick",
"slashed",
"slashing",
"slatey",
"slatternly",
"slaty",
"slaughterous",
"slav",
"slaveholding",
"slaveless",
"slavelike",
"slavic",
"slavish",
"slavonic",
"sleazy",
"sleek",
"sleeping",
"sleepless",
"sleepy",
"sleepyheaded",
"sleety",
"sleeved",
"sleeveless",
"slender",
"sliced",
"slick",
"slicked",
"sliding",
"slight",
"slighting",
"slim",
"slimed",
"slimy",
"slippered",
"slippery",
"slipping",
"slippy",
"slipshod",
"slithering",
"slithery",
"slivery",
"sloped",
"sloping",
"slopped",
"sloppy",
"sloshed",
"slothful",
"slouchy",
"sloughy",
"slovakian",
"slovenian",
"slovenly",
"slow",
"slowgoing",
"slubbed",
"sluggish",
"sluicing",
"slumberous",
"slumbery",
"slumbrous",
"slummy",
"slurred",
"slushy",
"sluttish",
"small",
"smaller",
"smallish",
"smarmy",
"smart",
"smashed",
"smashing",
"smelling",
"smelly",
"smiling",
"smitten",
"smoggy",
"smoked",
"smokeless",
"smoking",
"smoky",
"smoldering",
"smooth",
"smoothbore",
"smoothed",
"smoothened",
"smothered",
"smothering",
"smouldering",
"smudgy",
"smug",
"smuggled",
"smutty",
"snafu",
"snakelike",
"snaky",
"snappish",
"snappy",
"snarky",
"snarled",
"snarly",
"snazzy",
"sneak",
"sneaking",
"sneaky",
"sneering",
"sneezy",
"snide",
"sniffly",
"sniffy",
"snobbish",
"snobby",
"snoopy",
"snooty",
"snorty",
"snotty",
"snowbound",
"snowy",
"snub",
"snuff",
"snuffling",
"snuffly",
"snug",
"snuggled",
"soaked",
"soapy",
"soaring",
"sober",
"sobering",
"sobersided",
"sociable",
"social",
"socialised",
"socialist",
"socialistic",
"socialized",
"societal",
"sociobiologic",
"sociobiological",
"sociocultural",
"socioeconomic",
"sociolinguistic",
"sociological",
"sociopathic",
"socratic",
"sodden",
"sodding",
"soft",
"softened",
"softening",
"softheaded",
"softhearted",
"softish",
"soggy",
"soigne",
"soignee",
"soiled",
"solanaceous",
"solar",
"sold",
"soldierlike",
"soldierly",
"sole",
"soled",
"soleless",
"solemn",
"solicitous",
"solid",
"solidified",
"solitary",
"solo",
"solomonic",
"soluble",
"solvable",
"solved",
"solvent",
"somali",
"somalian",
"somatic",
"somatogenetic",
"somatogenic",
"somatosensory",
"somber",
"sombre",
"some",
"sometime",
"somniferous",
"somnific",
"somnolent",
"sonant",
"songful",
"songlike",
"sonic",
"sonorous",
"sonsie",
"sonsy",
"soothing",
"sooty",
"sophistic",
"sophistical",
"sophisticated",
"sophomore",
"soporiferous",
"soporific",
"soppy",
"sopranino",
"soprano",
"sorbed",
"sorbefacient",
"sorcerous",
"sordid",
"sore",
"sororal",
"sorrel",
"sorrowful",
"sorrowing",
"sorry",
"sorted",
"soteriological",
"sotho",
"sottish",
"soughing",
"sought",
"soulful",
"soulless",
"sound",
"soundable",
"sounding",
"soundless",
"soundproof",
"soupy",
"sour",
"soured",
"sourish",
"soused",
"south",
"southbound",
"southeast",
"southeasterly",
"southeastern",
"southeastward",
"southerly",
"southern",
"southernmost",
"southmost",
"southward",
"southwest",
"southwesterly",
"southwestern",
"southwestward",
"sovereign",
"soviet",
"sown",
"sozzled",
"spaced",
"spacey",
"spacial",
"spaciotemporal",
"spacious",
"spacy",
"spangled",
"spangly",
"spanish",
"spanking",
"spare",
"sparing",
"sparkling",
"sparkly",
"sparse",
"spartan",
"spasmodic",
"spastic",
"spatial",
"spatiotemporal",
"spattered",
"spatulate",
"spavined",
"spayed",
"speakable",
"speaking",
"special",
"specialised",
"specialistic",
"specialized",
"specifiable",
"specific",
"specified",
"specious",
"specked",
"speckled",
"speckless",
"spectacled",
"spectacular",
"spectral",
"spectrographic",
"spectrometric",
"spectroscopic",
"spectroscopical",
"specular",
"speculative",
"speechless",
"speedy",
"spellbinding",
"spellbound",
"spendable",
"spendthrift",
"spent",
"spermatic",
"spermicidal",
"spermous",
"spheric",
"spherical",
"spheroidal",
"sphingine",
"spic",
"spicate",
"spick",
"spicy",
"spiderlike",
"spiderly",
"spidery",
"spiffing",
"spiffy",
"spiked",
"spikelike",
"spiky",
"spinal",
"spindly",
"spineless",
"spinnable",
"spinnbar",
"spinose",
"spinous",
"spiny",
"spiral",
"spiraling",
"spirant",
"spirited",
"spiritless",
"spiritous",
"spiritual",
"spiritualist",
"spiritualistic",
"spirituous",
"spiteful",
"splanchnic",
"splashed",
"splashy",
"splattered",
"splay",
"splayfoot",
"splayfooted",
"splendid",
"splendiferous",
"splenetic",
"splenic",
"splinterless",
"splinterproof",
"splintery",
"split",
"splitting",
"splotched",
"spoilable",
"spoiled",
"spoilt",
"spoken",
"spondaic",
"spongelike",
"spongy",
"spontaneous",
"spooky",
"sporadic",
"sporogenous",
"sporting",
"sportive",
"sportsmanlike",
"sporty",
"spotless",
"spotted",
"spotty",
"spousal",
"spouting",
"sprawling",
"sprawly",
"spread",
"sprigged",
"sprightly",
"springless",
"springlike",
"springy",
"sprouted",
"spruce",
"spry",
"spumy",
"spunky",
"spurious",
"spurned",
"spurting",
"squab",
"squabby",
"squalid",
"squalling",
"squally",
"squamulose",
"squandered",
"square",
"squared",
"squarish",
"squashed",
"squashy",
"squat",
"squatty",
"squawky",
"squeaking",
"squeaky",
"squealing",
"squeamish",
"squeezable",
"squelched",
"squiffy",
"squiggly",
"squinched",
"squint",
"squinting",
"squinty",
"squirting",
"squishy",
"stabbing",
"stabile",
"stabilised",
"stabilising",
"stabilized",
"stabilizing",
"stable",
"staccato",
"stacked",
"staged",
"stagey",
"stagflationary",
"staggering",
"stagnant",
"stagy",
"staid",
"stainable",
"stained",
"stainless",
"stale",
"stalemated",
"stalinist",
"stalked",
"stalkless",
"stalwart",
"staminate",
"standard",
"standardised",
"standardized",
"standby",
"standing",
"standoffish",
"standpat",
"stannic",
"stannous",
"staphylococcal",
"staple",
"star",
"starboard",
"starchless",
"starchlike",
"starchy",
"staring",
"stark",
"starkers",
"starless",
"starlike",
"starlit",
"starred",
"starring",
"starry",
"starting",
"startled",
"startling",
"starved",
"starving",
"statant",
"stated",
"stateless",
"stately",
"statesmanlike",
"statesmanly",
"statewide",
"static",
"stationary",
"statistical",
"stative",
"statuary",
"statuesque",
"statute",
"statutory",
"staunch",
"steadfast",
"steadied",
"steady",
"steadying",
"stealthy",
"steamed",
"steaming",
"steamy",
"stearic",
"steely",
"steep",
"steepish",
"steerable",
"stellar",
"stellate",
"stemless",
"stemmatic",
"stemmed",
"stenographic",
"stenographical",
"stenosed",
"stenotic",
"stentorian",
"stepwise",
"stereo",
"stereophonic",
"stereoscopic",
"stereotyped",
"stereotypic",
"stereotypical",
"sterile",
"sterilised",
"sterilized",
"sterling",
"stern",
"sternal",
"sternutative",
"sternutatory",
"steroidal",
"stertorous",
"stewed",
"sticking",
"sticky",
"stiff",
"stifled",
"stifling",
"stigmatic",
"still",
"stillborn",
"stilly",
"stilted",
"stimulant",
"stimulated",
"stimulating",
"stimulative",
"stinging",
"stingless",
"stingy",
"stinking",
"stinky",
"stinting",
"stipendiary",
"stippled",
"stipulatory",
"stirred",
"stirring",
"stitched",
"stochastic",
"stock",
"stocked",
"stockinged",
"stocky",
"stodgy",
"stoic",
"stoical",
"stoichiometric",
"stolid",
"stoloniferous",
"stomachal",
"stomachic",
"stomatal",
"stomatous",
"stone",
"stoned",
"stoneless",
"stonelike",
"stony",
"stonyhearted",
"stooped",
"stooping",
"stoppable",
"stopped",
"stoppered",
"storeyed",
"storied",
"stormbound",
"stormproof",
"stormy",
"stout",
"stouthearted",
"stovepiped",
"straggling",
"straggly",
"straight",
"straightarrow",
"straightaway",
"straightforward",
"straightlaced",
"strained",
"straining",
"strait",
"straitlaced",
"stranded",
"strange",
"strangled",
"strapless",
"straplike",
"strapping",
"strategic",
"strategical",
"stratified",
"stravinskian",
"stravinskyan",
"straw",
"stray",
"straying",
"streaked",
"streaky",
"streaming",
"streamlined",
"streetwise",
"strengthened",
"strenuous",
"strep",
"streptococcal",
"streptococcic",
"stressed",
"stressful",
"stretch",
"stretchable",
"stretched",
"stretchy",
"striate",
"stricken",
"strict",
"strident",
"strikebound",
"striking",
"stringent",
"stringy",
"striped",
"stripped",
"stripy",
"strong",
"stroppy",
"struck",
"structural",
"structured",
"struggling",
"strung",
"stubbled",
"stubbly",
"stubborn",
"stubby",
"stuck",
"studded",
"studied",
"studious",
"stuffed",
"stuffy",
"stumpy",
"stung",
"stunned",
"stunning",
"stunted",
"stupefied",
"stupefying",
"stupendous",
"stupid",
"stuporous",
"sturdy",
"stygian",
"styleless",
"stylised",
"stylish",
"stylistic",
"stylized",
"styptic",
"suasible",
"suave",
"subacid",
"subacute",
"subalpine",
"subaltern",
"subaquatic",
"subaqueous",
"subarctic",
"subartesian",
"subatomic",
"subclavian",
"subclinical",
"subconscious",
"subcortical",
"subcutaneous",
"subduable",
"subdued",
"subdural",
"subfusc",
"subgross",
"subhuman",
"subjacent",
"subject",
"subjective",
"subjugable",
"subjugated",
"subjunctive",
"sublimate",
"sublimated",
"sublime",
"sublimed",
"subliminal",
"sublingual",
"subliterary",
"sublittoral",
"sublunar",
"sublunary",
"submarine",
"submerged",
"submergible",
"submersed",
"submersible",
"submissive",
"subnormal",
"subocean",
"suboceanic",
"subocular",
"suborbital",
"subordinate",
"subordinating",
"subordinative",
"subscribed",
"subscript",
"subsequent",
"subservient",
"subsidiary",
"subsidised",
"subsidized",
"subsonic",
"substandard",
"substantial",
"substantiating",
"substantiative",
"substantival",
"substantive",
"substitutable",
"substitute",
"subsurface",
"subterminal",
"subterranean",
"subterraneous",
"subtle",
"subtractive",
"subtropic",
"subtropical",
"suburban",
"suburbanised",
"suburbanized",
"subversive",
"succeeding",
"successful",
"successive",
"succinct",
"succinic",
"succulent",
"such",
"suchlike",
"suckled",
"suctorial",
"sudanese",
"sudden",
"sudorific",
"sudsy",
"suety",
"sufferable",
"suffering",
"sufficient",
"suffocating",
"suffocative",
"suffrutescent",
"suffusive",
"sufi",
"sugared",
"sugarless",
"sugary",
"suggestible",
"suggestive",
"suicidal",
"suitable",
"suited",
"sulcate",
"sulfuretted",
"sulfuric",
"sulfurized",
"sulfurous",
"sulky",
"sullen",
"sulphuretted",
"sulphuric",
"sulphurous",
"sultry",
"sumatran",
"sumerian",
"summary",
"summational",
"summative",
"summery",
"sumptuary",
"sumptuous",
"sunbaked",
"sunburned",
"sunburnt",
"sundried",
"sundry",
"sunk",
"sunken",
"sunless",
"sunlit",
"sunny",
"sunrise",
"sunset",
"sunstruck",
"suntanned",
"super",
"superable",
"superabundant",
"superannuated",
"superb",
"supercharged",
"supercilious",
"supercritical",
"supererogatory",
"superfatted",
"superficial",
"superfine",
"superfluous",
"superhuman",
"superimposed",
"superincumbent",
"superior",
"superjacent",
"superlative",
"superlunar",
"superlunary",
"supernal",
"supernatant",
"supernatural",
"supernaturalist",
"supernormal",
"supernumerary",
"superordinate",
"superpatriotic",
"superposable",
"supersaturated",
"superscript",
"supersensitised",
"supersensitive",
"supersensitized",
"supersonic",
"superstitious",
"supervised",
"supervisory",
"supine",
"supperless",
"supple",
"supplemental",
"supplementary",
"suppliant",
"supplicant",
"supplicatory",
"supportable",
"supported",
"supporting",
"supportive",
"supposable",
"supposed",
"suppositional",
"suppositious",
"supposititious",
"suppressed",
"suppressive",
"suppurative",
"supranational",
"supranormal",
"supraocular",
"supraorbital",
"suprasegmental",
"supreme",
"surd",
"sure",
"surefooted",
"surface",
"surficial",
"surgical",
"surging",
"surly",
"surmisable",
"surmountable",
"surmounted",
"surpassing",
"surpliced",
"surplus",
"surprised",
"surprising",
"surreal",
"surrealistic",
"surreptitious",
"surrogate",
"surrounded",
"surrounding",
"surviving",
"susceptible",
"suspect",
"suspected",
"suspended",
"suspenseful",
"suspensive",
"suspicious",
"sustainable",
"sustained",
"sustentacular",
"susurrant",
"susurrous",
"svelte",
"swagger",
"swaggering",
"swampy",
"swank",
"swanky",
"swart",
"swarthy",
"swashbuckling",
"swayback",
"swaybacked",
"swazi",
"swedish",
"sweeping",
"sweet",
"sweetened",
"sweetheart",
"sweetish",
"swell",
"swelled",
"sweltering",
"sweltry",
"swept",
"sweptback",
"sweptwing",
"swift",
"swimming",
"swingeing",
"swinging",
"swingy",
"swinish",
"swish",
"swishy",
"swiss",
"swollen",
"swooning",
"swordlike",
"sworn",
"sybaritic",
"sycophantic",
"syllabic",
"syllabled",
"syllogistic",
"sylphic",
"sylphlike",
"sylvan",
"symbiotic",
"symbolic",
"symbolical",
"symmetric",
"symmetrical",
"sympathetic",
"sympathomimetic",
"sympatric",
"sympetalous",
"symphonic",
"symphonious",
"symptomatic",
"symptomless",
"synaesthetic",
"synaptic",
"syncarpous",
"synchronal",
"synchronic",
"synchronised",
"synchronized",
"synchronous",
"synclinal",
"syncopated",
"syncretic",
"syncretical",
"syncretistic",
"syncretistical",
"syndetic",
"synecdochic",
"synecdochical",
"synergetic",
"synergistic",
"synesthetic",
"synoecious",
"synoicous",
"synonymous",
"synoptic",
"synoptical",
"synovial",
"synsemantic",
"syntactic",
"syntactical",
"syntagmatic",
"synthetic",
"synthetical",
"syphilitic",
"syrian",
"syrupy",
"systematic",
"systemic",
"systolic",
"tabby",
"taboo",
"tabu",
"tabular",
"tacit",
"taciturn",
"tacky",
"tactful",
"tactical",
"tactile",
"tactless",
"tactual",
"tagged",
"tahitian",
"tailed",
"tailless",
"taillike",
"tailored",
"tainted",
"taiwanese",
"tajikistani",
"taken",
"takeout",
"taking",
"talebearing",
"talented",
"talentless",
"taliped",
"talismanic",
"talkative",
"talky",
"tall",
"tallish",
"taloned",
"tamable",
"tame",
"tameable",
"tamed",
"tamil",
"tangential",
"tangerine",
"tangible",
"tangled",
"tangy",
"tanned",
"tannic",
"tannish",
"tantalising",
"tantalizing",
"tantamount",
"tantric",
"tantrik",
"tanzanian",
"taoist",
"taped",
"tapered",
"tapering",
"tapestried",
"tapped",
"tardive",
"tardy",
"tarry",
"tarsal",
"tart",
"tartarean",
"tartaric",
"tasmanian",
"tasseled",
"tasselled",
"tasteful",
"tasteless",
"tasty",
"tatterdemalion",
"tattered",
"tattling",
"tatty",
"taunting",
"taupe",
"taurine",
"taut",
"tautologic",
"tautological",
"tawdry",
"tawny",
"taxable",
"taxing",
"taxonomic",
"taxonomical",
"taxpaying",
"teachable",
"teal",
"tearaway",
"tearful",
"tearing",
"tearless",
"teary",
"teased",
"teasing",
"technical",
"technological",
"technophilic",
"technophobic",
"techy",
"tectonic",
"tedious",
"teeming",
"teen",
"teenage",
"teenaged",
"teensy",
"teentsy",
"teeny",
"teetotal",
"tegular",
"telegnostic",
"telegraphic",
"telemetered",
"teleological",
"telepathic",
"telephonic",
"telescoped",
"telescopic",
"telling",
"telltale",
"tellurian",
"telluric",
"telocentric",
"temerarious",
"temperamental",
"temperate",
"tempered",
"tempering",
"tempestuous",
"temporal",
"temporary",
"temptable",
"tempting",
"tenable",
"tenacious",
"tenanted",
"tendencious",
"tendentious",
"tender",
"tenderhearted",
"tenderised",
"tenderized",
"tending",
"tendinous",
"tenebrific",
"tenebrious",
"tenebrous",
"tenfold",
"tenor",
"tense",
"tensed",
"tensile",
"tensional",
"tensionless",
"tentacled",
"tentacular",
"tentative",
"tenth",
"tenuous",
"tenured",
"tepid",
"teratogenic",
"terefah",
"terete",
"terminable",
"terminal",
"terminated",
"terminative",
"terminological",
"ternary",
"ternate",
"terpsichorean",
"terrene",
"terrestrial",
"terrible",
"terrific",
"terrified",
"terrifying",
"territorial",
"terse",
"tertian",
"tertiary",
"tessellated",
"testaceous",
"testamentary",
"testate",
"tested",
"testicular",
"testimonial",
"testy",
"tetanic",
"tetchy",
"tethered",
"tetragonal",
"tetramerous",
"tetrametric",
"tetravalent",
"teutonic",
"texan",
"textbook",
"textile",
"textual",
"textured",
"thai",
"thalamocortical",
"thalassic",
"thalloid",
"thallophytic",
"thankful",
"thankless",
"thawed",
"theatrical",
"theban",
"theist",
"theistic",
"theistical",
"thematic",
"then",
"thenal",
"thenar",
"theocratic",
"theological",
"theoretic",
"theoretical",
"theosophical",
"therapeutic",
"therapeutical",
"thermal",
"thermic",
"thermionic",
"thermodynamic",
"thermodynamical",
"thermoelectric",
"thermolabile",
"thermometric",
"thermonuclear",
"thermoplastic",
"thermoset",
"thermosetting",
"thermostatic",
"thespian",
"thick",
"thickened",
"thickening",
"thickheaded",
"thickset",
"thickspread",
"thieving",
"thievish",
"thin",
"thinkable",
"thinking",
"thinned",
"third",
"thirdhand",
"thirsty",
"thirteen",
"thirteenth",
"thirtieth",
"thirty",
"thistlelike",
"thoracic",
"thoreauvian",
"thoriated",
"thornless",
"thorny",
"thorough",
"thoroughbred",
"thoroughgoing",
"thoughtful",
"thoughtless",
"thousand",
"thousandth",
"thracian",
"threadbare",
"threaded",
"threadlike",
"thready",
"threatened",
"threatening",
"three",
"threefold",
"threepenny",
"threescore",
"thriftless",
"thrifty",
"thrilled",
"thrillful",
"thrilling",
"thriving",
"throated",
"throaty",
"throbbing",
"thrombosed",
"thronged",
"through",
"throwaway",
"throwback",
"thrown",
"thudding",
"thumbed",
"thumping",
"thundering",
"thunderous",
"thunderstruck",
"thundery",
"thwarted",
"thwarting",
"thwartwise",
"thyroid",
"thyroidal",
"thyrotoxic",
"tibetan",
"tibial",
"tickling",
"ticklish",
"tidal",
"tiddly",
"tidy",
"tied",
"tiered",
"tigerish",
"tight",
"tightfisted",
"tightfitting",
"tightlipped",
"tiled",
"tillable",
"tilled",
"tilted",
"timbered",
"timed",
"timeless",
"timely",
"timeserving",
"timeworn",
"timid",
"timorese",
"timorous",
"tined",
"tingling",
"tinkling",
"tinkly",
"tinned",
"tinny",
"tinpot",
"tinseled",
"tinselly",
"tiny",
"tipped",
"tippy",
"tipsy",
"tiptoe",
"tiptop",
"tired",
"tireless",
"tiresome",
"tiring",
"titanic",
"titillated",
"titillating",
"titled",
"tittering",
"titular",
"titulary",
"toadyish",
"toasted",
"tobagonian",
"toed",
"toeless",
"together",
"togged",
"togolese",
"toiling",
"toilsome",
"token",
"tokenish",
"tolerable",
"tolerant",
"tomboyish",
"tomentose",
"tomentous",
"tonal",
"toned",
"toneless",
"tongan",
"tongued",
"tongueless",
"tonguelike",
"tonic",
"tonsorial",
"tonsured",
"toothed",
"toothless",
"toothlike",
"toothsome",
"toothy",
"topical",
"topknotted",
"topless",
"topmost",
"topnotch",
"topographic",
"topographical",
"topologic",
"topological",
"topped",
"topping",
"tops",
"tormented",
"torn",
"toroidal",
"torpid",
"torrential",
"torrid",
"tortious",
"tortuous",
"tortured",
"torturesome",
"torturing",
"torturous",
"torulose",
"total",
"totaled",
"totalistic",
"totalitarian",
"totemic",
"totipotent",
"tottering",
"tottery",
"touchable",
"touched",
"touching",
"touchy",
"tough",
"toughened",
"toupeed",
"touristed",
"touristy",
"tousled",
"towering",
"towheaded",
"toxic",
"toxicant",
"toxicologic",
"toxicological",
"trabeate",
"trabeated",
"trabecular",
"trabeculate",
"traceable",
"tracheal",
"trackable",
"tracked",
"trackless",
"tractable",
"tractile",
"tractive",
"trademarked",
"traditional",
"traditionalist",
"tragic",
"tragical",
"tragicomic",
"tragicomical",
"trained",
"traitorous",
"tralatitious",
"tramontane",
"trancelike",
"tranquil",
"tranquilising",
"tranquilizing",
"tranquillising",
"tranquillizing",
"transactinide",
"transalpine",
"transatlantic",
"transcendent",
"transcendental",
"transcribed",
"transcultural",
"transcutaneous",
"transdermal",
"transdermic",
"transeunt",
"transferable",
"transferrable",
"transfixed",
"transformable",
"transformed",
"transgender",
"transgendered",
"transient",
"transistorised",
"transistorized",
"transitional",
"transitive",
"transitory",
"translatable",
"translational",
"translucent",
"translunar",
"translunary",
"transmissible",
"transmittable",
"transmitted",
"transmontane",
"transmundane",
"transmutable",
"transnational",
"transoceanic",
"transonic",
"transparent",
"transpiring",
"transplacental",
"transplantable",
"transpolar",
"transportable",
"transposable",
"transposed",
"transsexual",
"transuranic",
"transversal",
"transverse",
"transvestic",
"transvestite",
"trapezoidal",
"trapped",
"trashy",
"traumatic",
"travelable",
"traveled",
"travelled",
"traversable",
"treacherous",
"treacly",
"treasonable",
"treasonous",
"treasured",
"treated",
"treble",
"treed",
"treeless",
"treelike",
"tref",
"trembling",
"tremendous",
"tremulous",
"trenchant",
"trendsetting",
"trendy",
"trepid",
"trespassing",
"triangular",
"triangulate",
"triassic",
"tribadistic",
"tribal",
"tributary",
"tricentenary",
"tricentennial",
"trichromatic",
"trichrome",
"tricksy",
"tricky",
"triclinic",
"tricolor",
"tricuspid",
"tricuspidate",
"tried",
"triennial",
"trifid",
"trifling",
"trifoliate",
"trifoliated",
"trifoliolate",
"trig",
"trigonal",
"trigonometric",
"trihydroxy",
"trilateral",
"trilingual",
"trilled",
"trillion",
"trillionth",
"trilobate",
"trilobated",
"trilobed",
"trim",
"trimmed",
"trimotored",
"trinidadian",
"trinuclear",
"trinucleate",
"trinucleated",
"tripartite",
"tripinnate",
"tripinnated",
"tripinnatifid",
"triple",
"triplex",
"triploid",
"tripping",
"tritanopic",
"trite",
"triumphal",
"triumphant",
"triune",
"trivalent",
"trivial",
"trochaic",
"trojan",
"trophic",
"trophoblastic",
"trophotropic",
"tropic",
"tropical",
"troubled",
"troublesome",
"troubling",
"troublous",
"trousered",
"truant",
"truculent",
"true",
"truehearted",
"truncate",
"truncated",
"trussed",
"trusted",
"trustful",
"trusting",
"trustworthy",
"trusty",
"truthful",
"trying",
"tsarist",
"tsaristic",
"tubal",
"tubby",
"tubed",
"tubeless",
"tubelike",
"tubercular",
"tuberculate",
"tuberculoid",
"tuberculous",
"tuberous",
"tubular",
"tucked",
"tudor",
"tufted",
"tumescent",
"tumid",
"tumultuous",
"tuneful",
"tuneless",
"tunisian",
"tuppeny",
"turbaned",
"turbid",
"turbinate",
"turbulent",
"turgid",
"turkic",
"turkish",
"turkmen",
"turned",
"tuscan",
"tusked",
"tutelar",
"tutelary",
"tutorial",
"tuxedoed",
"twee",
"tweedy",
"twelfth",
"twelve",
"twentieth",
"twenty",
"twiggy",
"twiglike",
"twilight",
"twilit",
"twilled",
"twin",
"twinkling",
"twinkly",
"twinned",
"twinning",
"twisted",
"twisting",
"twisty",
"twofold",
"twopenny",
"twoscore",
"tympanic",
"tympanitic",
"typic",
"typical",
"typographic",
"typographical",
"tyrannic",
"tyrannical",
"tyrannous",
"tyrolean",
"tyrolese",
"tzarist",
"ubiquitous",
"ugandan",
"ugly",
"ukrainian",
"ulcerated",
"ulcerative",
"ulcerous",
"ulnar",
"ulterior",
"ultimate",
"ultimo",
"ultra",
"ultramarine",
"ultramodern",
"ultramontane",
"ultrasonic",
"ultraviolet",
"umbellar",
"umbellate",
"umbelliferous",
"umbelliform",
"umber",
"umbilical",
"umbilicate",
"umbrageous",
"umbrella",
"umbrellalike",
"umpteen",
"umpteenth",
"umptieth",
"umteen",
"umteenth",
"unabashed",
"unabated",
"unable",
"unabridged",
"unabused",
"unaccented",
"unacceptable",
"unaccepted",
"unaccessible",
"unaccommodating",
"unaccompanied",
"unaccountable",
"unaccredited",
"unaccustomed",
"unachievable",
"unacknowledged",
"unacquainted",
"unacquisitive",
"unactable",
"unadaptable",
"unadapted",
"unaddicted",
"unaddressed",
"unadjustable",
"unadjusted",
"unadoptable",
"unadorned",
"unadulterated",
"unadventurous",
"unadvisable",
"unadvised",
"unaerated",
"unaesthetic",
"unaffected",
"unaffecting",
"unaffectionate",
"unaffiliated",
"unaffixed",
"unafraid",
"unaged",
"unaggressive",
"unagitated",
"unaided",
"unaired",
"unairworthy",
"unalarming",
"unalert",
"unalienable",
"unalike",
"unalloyed",
"unalterable",
"unaltered",
"unambiguous",
"unambitious",
"unamended",
"unanalyzable",
"unanalyzed",
"unangry",
"unanimated",
"unanimous",
"unannealed",
"unannounced",
"unanswerable",
"unanswered",
"unanticipated",
"unapologetic",
"unappareled",
"unapparent",
"unappealable",
"unappealing",
"unappeasable",
"unappendaged",
"unappetising",
"unappetizing",
"unappreciated",
"unappreciative",
"unapprehensive",
"unapproachable",
"unarbitrary",
"unarguable",
"unargumentative",
"unarmed",
"unarmored",
"unarmoured",
"unarticulate",
"unarticulated",
"unartistic",
"unary",
"unascertainable",
"unascribable",
"unashamed",
"unasked",
"unassailable",
"unassertive",
"unassignable",
"unassigned",
"unassisted",
"unassuming",
"unassured",
"unasterisked",
"unattached",
"unattackable",
"unattainable",
"unattended",
"unattired",
"unattractive",
"unattributable",
"unauthentic",
"unauthorised",
"unauthorized",
"unavailable",
"unavailing",
"unavenged",
"unavoidable",
"unavowed",
"unawakened",
"unaware",
"unawed",
"unbacked",
"unbaffled",
"unbalanced",
"unbalconied",
"unbanded",
"unbaptised",
"unbaptized",
"unbarred",
"unbarreled",
"unbarrelled",
"unbearable",
"unbeatable",
"unbeaten",
"unbecoming",
"unbefitting",
"unbeholden",
"unbeknown",
"unbeknownst",
"unbelievable",
"unbelieving",
"unbeloved",
"unbelted",
"unbendable",
"unbending",
"unbeneficed",
"unbent",
"unbiased",
"unbiassed",
"unbigoted",
"unbitter",
"unbleached",
"unblemished",
"unblended",
"unblessed",
"unblinking",
"unbloody",
"unblushing",
"unbodied",
"unbolted",
"unbooked",
"unbordered",
"unborn",
"unbound",
"unbounded",
"unbowed",
"unbraced",
"unbrainwashed",
"unbranched",
"unbranching",
"unbranded",
"unbreakable",
"unbridgeable",
"unbridled",
"unbroken",
"unbrushed",
"unburdened",
"unburied",
"unburnished",
"unbuttoned",
"uncamphorated",
"uncanny",
"uncapped",
"uncarbonated",
"uncaring",
"uncarpeted",
"uncarved",
"uncastrated",
"uncategorised",
"uncategorized",
"uncaulked",
"uncaused",
"unceasing",
"uncensored",
"unceremonial",
"unceremonious",
"uncertain",
"uncertified",
"unchained",
"unchallengeable",
"unchallenged",
"unchangeable",
"unchanged",
"unchanging",
"uncharged",
"uncharitable",
"uncharted",
"unchartered",
"unchaste",
"uncheckable",
"unchecked",
"uncheerful",
"unchewable",
"unchivalrous",
"unchristian",
"unchristianly",
"unchristlike",
"uncial",
"uncivil",
"uncivilised",
"uncivilized",
"unclad",
"unclaimed",
"unclassifiable",
"unclassified",
"unclean",
"uncleanly",
"unclear",
"uncleared",
"unclimbable",
"unclipped",
"unclogged",
"unclothed",
"unclouded",
"uncluttered",
"uncoated",
"uncoerced",
"uncoiled",
"uncollected",
"uncollectible",
"uncolored",
"uncoloured",
"uncolumned",
"uncombable",
"uncombed",
"uncombined",
"uncomely",
"uncomfortable",
"uncommercial",
"uncommitted",
"uncommon",
"uncommunicative",
"uncomparable",
"uncompartmented",
"uncompassionate",
"uncompensated",
"uncompetitive",
"uncomplaining",
"uncomplete",
"uncompleted",
"uncomplicated",
"uncomplimentary",
"uncompounded",
"uncomprehended",
"uncomprehending",
"uncompromising",
"unconcealed",
"unconcerned",
"unconditional",
"unconditioned",
"unconfessed",
"unconfined",
"unconfirmed",
"unconformable",
"unconformist",
"unconfused",
"uncongenial",
"unconnected",
"unconquerable",
"unconquered",
"unconscientious",
"unconscionable",
"unconscious",
"unconsecrated",
"unconsidered",
"unconsolable",
"unconsolidated",
"unconstipated",
"unconstrained",
"unconstricted",
"unconstructive",
"unconsumed",
"unconsummated",
"uncontaminated",
"uncontaminating",
"uncontested",
"uncontrived",
"uncontrollable",
"uncontrolled",
"uncontroversial",
"unconventional",
"unconverted",
"unconvertible",
"unconvinced",
"unconvincing",
"uncooked",
"uncool",
"uncooperative",
"uncoordinated",
"uncordial",
"uncorrectable",
"uncorrected",
"uncorrelated",
"uncorroborated",
"uncorrupted",
"uncounted",
"uncoupled",
"uncousinly",
"uncouth",
"uncovered",
"uncrannied",
"uncreased",
"uncreative",
"uncritical",
"uncropped",
"uncrossed",
"uncrowded",
"uncrowned",
"uncrystallised",
"uncrystallized",
"unctuous",
"uncultivable",
"uncultivatable",
"uncultivated",
"uncultured",
"uncurbed",
"uncured",
"uncurled",
"uncurtained",
"uncurved",
"uncurving",
"uncut",
"undamaged",
"undatable",
"undated",
"undaunted",
"undeceived",
"undecided",
"undecipherable",
"undeciphered",
"undeclared",
"undecomposable",
"undecomposed",
"undecorated",
"undedicated",
"undefeated",
"undefendable",
"undefended",
"undeferential",
"undefiled",
"undefinable",
"undefined",
"undelineated",
"undemanding",
"undemocratic",
"undemonstrative",
"undeniable",
"undependable",
"undepicted",
"under",
"underactive",
"underage",
"underarm",
"underbred",
"underclass",
"underclothed",
"undercoated",
"undercover",
"underdeveloped",
"underdone",
"underdressed",
"undereducated",
"underemployed",
"underfed",
"underground",
"underhand",
"underhanded",
"underhung",
"underivative",
"underived",
"underlying",
"undermanned",
"undermentioned",
"undernourished",
"underpopulated",
"underprivileged",
"undersea",
"undersealed",
"undersexed",
"undershot",
"undersize",
"undersized",
"underslung",
"understaffed",
"understandable",
"understanding",
"understated",
"understood",
"underwater",
"underway",
"underweight",
"undescended",
"undescriptive",
"undeserved",
"undeserving",
"undesigned",
"undesirable",
"undesired",
"undesiring",
"undesirous",
"undestroyable",
"undetectable",
"undetected",
"undeterminable",
"undetermined",
"undeterred",
"undeveloped",
"undeviating",
"undiagnosable",
"undiagnosed",
"undigested",
"undignified",
"undiluted",
"undiminished",
"undimmed",
"undiplomatic",
"undirected",
"undiscerning",
"undischarged",
"undisciplined",
"undisclosed",
"undiscouraged",
"undiscoverable",
"undiscovered",
"undisguised",
"undismayed",
"undisputable",
"undisputed",
"undissolved",
"undistinguished",
"undistorted",
"undistributed",
"undisturbed",
"undiversified",
"undividable",
"undivided",
"undoable",
"undocumented",
"undogmatic",
"undogmatical",
"undomestic",
"undomesticated",
"undone",
"undrained",
"undramatic",
"undraped",
"undrawn",
"undreamed",
"undreamt",
"undressed",
"undried",
"undrinkable",
"undue",
"undulant",
"undulate",
"undulatory",
"undutiful",
"undyed",
"undying",
"undynamic",
"uneager",
"unearned",
"unearthly",
"uneasy",
"uneatable",
"uneconomic",
"uneconomical",
"unedifying",
"unedited",
"uneducated",
"uneffective",
"unelaborate",
"unelaborated",
"unembarrassed",
"unembellished",
"unembodied",
"unemotional",
"unemphatic",
"unemployable",
"unemployed",
"unenclosed",
"unencouraging",
"unencumbered",
"unended",
"unending",
"unendowed",
"unendurable",
"unenergetic",
"unenforceable",
"unenforced",
"unengaged",
"unenlightened",
"unenlightening",
"unenlivened",
"unenterprising",
"unenthusiastic",
"unentitled",
"unenviable",
"unequal",
"unequaled",
"unequalised",
"unequalized",
"unequalled",
"unequipped",
"unequivocal",
"unerasable",
"unerect",
"unerring",
"unessential",
"unestablished",
"unethical",
"uneven",
"uneventful",
"unexacting",
"unexampled",
"unexceeded",
"unexcelled",
"unexceptionable",
"unexceptional",
"unexchangeable",
"unexcitable",
"unexcited",
"unexciting",
"unexclusive",
"unexcused",
"unexhausted",
"unexpansive",
"unexpected",
"unexpendable",
"unexpended",
"unexpired",
"unexplainable",
"unexplained",
"unexploded",
"unexploited",
"unexplorative",
"unexploratory",
"unexplored",
"unexportable",
"unexpressed",
"unexpressible",
"unexpressive",
"unexpurgated",
"unextended",
"unfaceted",
"unfading",
"unfailing",
"unfair",
"unfaithful",
"unfaltering",
"unfamiliar",
"unfashionable",
"unfastened",
"unfastidious",
"unfathomable",
"unfathomed",
"unfattened",
"unfavorable",
"unfavourable",
"unfearing",
"unfeasible",
"unfeathered",
"unfed",
"unfeeling",
"unfeigned",
"unfeminine",
"unfenced",
"unfermented",
"unfertile",
"unfertilised",
"unfertilized",
"unfettered",
"unfilled",
"unfilmed",
"unfinished",
"unfirm",
"unfit",
"unfitting",
"unfixed",
"unflagging",
"unflappable",
"unflattering",
"unflavored",
"unflavoured",
"unflawed",
"unfledged",
"unflinching",
"unfluctuating",
"unflurried",
"unflustered",
"unfocused",
"unfocussed",
"unforbearing",
"unforced",
"unforceful",
"unforeseeable",
"unforeseen",
"unforesightful",
"unforested",
"unforfeitable",
"unforgettable",
"unforgivable",
"unforgiving",
"unformed",
"unfortunate",
"unfounded",
"unframed",
"unfree",
"unfrequented",
"unfretted",
"unfriendly",
"unfrightened",
"unfrosted",
"unfrozen",
"unfruitful",
"unfueled",
"unfulfilled",
"unfunctional",
"unfunded",
"unfunny",
"unfurnished",
"unfurrowed",
"ungainly",
"ungallant",
"ungarbed",
"ungarmented",
"ungathered",
"ungeared",
"ungenerous",
"ungentle",
"ungentlemanlike",
"ungentlemanly",
"ungetatable",
"unglamorous",
"unglamourous",
"unglazed",
"ungodly",
"ungovernable",
"ungoverned",
"ungraceful",
"ungracious",
"ungraded",
"ungrammatical",
"ungrasped",
"ungrateful",
"ungratified",
"ungratifying",
"ungreased",
"ungregarious",
"ungroomed",
"ungrudging",
"ungual",
"unguaranteed",
"unguarded",
"unguiculate",
"unguiculated",
"unguided",
"ungulate",
"ungulated",
"ungummed",
"ungusseted",
"unhallowed",
"unhampered",
"unhappy",
"unhardened",
"unharmed",
"unharmonious",
"unhatched",
"unhazardous",
"unheaded",
"unhealed",
"unhealthful",
"unhealthy",
"unhearable",
"unheard",
"unhearing",
"unheated",
"unheeded",
"unheeding",
"unhelpful",
"unheralded",
"unhesitating",
"unhewn",
"unhindered",
"unhinged",
"unholy",
"unhomogenised",
"unhomogenized",
"unhoped",
"unhopeful",
"unhuman",
"unhumorous",
"unhurried",
"unhurt",
"unhygienic",
"uniate",
"unicameral",
"unicellular",
"unicuspid",
"unidentifiable",
"unidentified",
"unidimensional",
"unidirectional",
"unifacial",
"unified",
"unifilar",
"unifoliate",
"uniform",
"uniformed",
"unifying",
"unilateral",
"unilluminated",
"unilluminating",
"unimaginable",
"unimaginative",
"unimagined",
"unimodal",
"unimpaired",
"unimpassioned",
"unimpeachable",
"unimpeded",
"unimportant",
"unimposing",
"unimpregnated",
"unimpressed",
"unimpressive",
"unimprisoned",
"unimproved",
"unincorporated",
"uninebriated",
"uninfected",
"uninflected",
"uninfluenced",
"uninfluential",
"uninformative",
"uninformed",
"uninhabitable",
"uninhabited",
"uninhibited",
"uninitiate",
"uninitiated",
"uninjectable",
"uninjured",
"uninominal",
"uninquiring",
"uninquisitive",
"uninspired",
"uninspiring",
"uninstructed",
"uninstructive",
"uninsurable",
"uninsured",
"unintegrated",
"unintelligent",
"unintelligible",
"unintended",
"unintentional",
"uninterested",
"uninteresting",
"uninterrupted",
"unintimidated",
"unintoxicated",
"unintrusive",
"uninucleate",
"uninventive",
"uninvited",
"uninviting",
"uninvolved",
"union",
"unionised",
"unionized",
"uniovular",
"uniovulate",
"uniparous",
"unipolar",
"unique",
"unironed",
"unisex",
"unisexual",
"unitarian",
"unitary",
"united",
"univalent",
"univalve",
"universal",
"universalist",
"universalistic",
"univocal",
"unjointed",
"unjust",
"unjustifiable",
"unjustified",
"unkempt",
"unkept",
"unkeyed",
"unkind",
"unkindled",
"unkindly",
"unknowable",
"unknowing",
"unknowledgeable",
"unknown",
"unlabeled",
"unlabelled",
"unlaced",
"unladylike",
"unlamented",
"unlatched",
"unlaureled",
"unlaurelled",
"unlawful",
"unleaded",
"unlearned",
"unleavened",
"unlettered",
"unlicenced",
"unlicensed",
"unlifelike",
"unlighted",
"unlikable",
"unlike",
"unlikeable",
"unlikely",
"unlimited",
"unlined",
"unlipped",
"unlisted",
"unlit",
"unliterary",
"unlittered",
"unlivable",
"unliveable",
"unliveried",
"unloaded",
"unlobed",
"unlocated",
"unlocked",
"unlogical",
"unlovable",
"unloved",
"unlovely",
"unloving",
"unlubricated",
"unlucky",
"unmade",
"unmalicious",
"unmalleable",
"unmalted",
"unmanageable",
"unmanful",
"unmanlike",
"unmanly",
"unmanned",
"unmannered",
"unmannerly",
"unmapped",
"unmarked",
"unmarketable",
"unmarred",
"unmarried",
"unmatchable",
"unmatched",
"unmated",
"unmeaning",
"unmeasurable",
"unmeasured",
"unmechanical",
"unmechanised",
"unmechanized",
"unmediated",
"unmedical",
"unmedicative",
"unmedicinal",
"unmelodic",
"unmelodious",
"unmelted",
"unmemorable",
"unmentionable",
"unmercenary",
"unmerchantable",
"unmerciful",
"unmerited",
"unmeritorious",
"unmethodical",
"unmilitary",
"unmindful",
"unmined",
"unmingled",
"unmistakable",
"unmitigable",
"unmitigated",
"unmixable",
"unmixed",
"unmoderated",
"unmodernised",
"unmodernized",
"unmodifiable",
"unmodified",
"unmodulated",
"unmolested",
"unmortgaged",
"unmotivated",
"unmotorised",
"unmotorized",
"unmourned",
"unmovable",
"unmoved",
"unmoving",
"unmown",
"unmusical",
"unmutilated",
"unmyelinated",
"unnameable",
"unnamed",
"unnatural",
"unnaturalised",
"unnaturalized",
"unnavigable",
"unnecessary",
"unneeded",
"unneighborly",
"unneighbourly",
"unnerved",
"unnerving",
"unneurotic",
"unnotched",
"unnoted",
"unnoticeable",
"unnoticed",
"unnourished",
"unnumberable",
"unnumbered",
"unnumerable",
"unobjectionable",
"unobjective",
"unobligated",
"unobliging",
"unobservable",
"unobservant",
"unobserved",
"unobstructed",
"unobtainable",
"unobtrusive",
"unobvious",
"unoccupied",
"unoffending",
"unofficial",
"unoiled",
"unopen",
"unopened",
"unopposable",
"unopposed",
"unordered",
"unorganised",
"unorganized",
"unoriented",
"unoriginal",
"unornamented",
"unorthodox",
"unostentatious",
"unowned",
"unoxygenated",
"unpackaged",
"unpaid",
"unpainful",
"unpaintable",
"unpainted",
"unpaired",
"unpalatable",
"unparallel",
"unparalleled",
"unpardonable",
"unparented",
"unparliamentary",
"unpartitioned",
"unpassable",
"unpasteurised",
"unpasteurized",
"unpatented",
"unpatriotic",
"unpatronised",
"unpatronized",
"unpatterned",
"unpaved",
"unpeaceable",
"unpeaceful",
"unpeopled",
"unperceivable",
"unperceived",
"unperceiving",
"unperceptive",
"unperformed",
"unpermed",
"unpermissive",
"unperplexed",
"unpersuadable",
"unpersuaded",
"unpersuasive",
"unperturbed",
"unpictured",
"unpicturesque",
"unpierced",
"unpigmented",
"unpillared",
"unpitying",
"unplaced",
"unplanned",
"unplanted",
"unplayable",
"unplayful",
"unpleasant",
"unpleasing",
"unpledged",
"unploughed",
"unplowed",
"unplumbed",
"unpointed",
"unpolished",
"unpolitical",
"unpolluted",
"unpompous",
"unpopular",
"unpopulated",
"unportable",
"unposed",
"unpotted",
"unpowered",
"unpracticed",
"unpractised",
"unprecedented",
"unpredictable",
"unpredicted",
"unpredictive",
"unprejudiced",
"unpremeditated",
"unprepared",
"unprepossessing",
"unpresentable",
"unpresidential",
"unpressed",
"unpretending",
"unpretentious",
"unpreventable",
"unpriestly",
"unprincipled",
"unprintable",
"unproblematic",
"unprocessed",
"unprocurable",
"unproductive",
"unprofessional",
"unprofitable",
"unprogressive",
"unpromised",
"unpromising",
"unprompted",
"unpronounceable",
"unprophetic",
"unpropitious",
"unprotected",
"unprotective",
"unprovable",
"unproved",
"unproven",
"unprovocative",
"unprovoked",
"unprovoking",
"unpublishable",
"unpublished",
"unpunctual",
"unpunished",
"unpurified",
"unqualified",
"unquenchable",
"unquestionable",
"unquestioned",
"unquestioning",
"unquiet",
"unquotable",
"unraised",
"unranked",
"unratable",
"unratified",
"unreachable",
"unreached",
"unreactive",
"unread",
"unreadable",
"unready",
"unreal",
"unrealised",
"unrealistic",
"unrealizable",
"unrealized",
"unreasonable",
"unreasoning",
"unreassuring",
"unreceptive",
"unreciprocated",
"unrecognisable",
"unrecognised",
"unrecognizable",
"unrecognized",
"unreconcilable",
"unreconciled",
"unreconstructed",
"unrecorded",
"unrecoverable",
"unredeemable",
"unredeemed",
"unreduced",
"unrefined",
"unreflected",
"unreflective",
"unreformable",
"unreformed",
"unrefreshed",
"unregenerate",
"unregenerated",
"unregistered",
"unregretful",
"unregretting",
"unregulated",
"unrehearsed",
"unrelated",
"unrelaxed",
"unreleased",
"unrelenting",
"unreliable",
"unrelieved",
"unremarkable",
"unremarked",
"unremedied",
"unremitting",
"unremorseful",
"unremunerative",
"unrenewable",
"unrenewed",
"unrentable",
"unrepaired",
"unrepeatable",
"unrepentant",
"unreplaceable",
"unreportable",
"unreported",
"unrepressed",
"unreproducible",
"unrequested",
"unrequited",
"unresentful",
"unreserved",
"unresistant",
"unresisting",
"unresolvable",
"unresolved",
"unrespectable",
"unresponsive",
"unrested",
"unrestrained",
"unrestricted",
"unrestrictive",
"unretentive",
"unretrievable",
"unrevealed",
"unreverberant",
"unrevised",
"unrevived",
"unrewarded",
"unrewarding",
"unrhetorical",
"unrhymed",
"unrhythmic",
"unrhythmical",
"unrifled",
"unrigged",
"unrighteous",
"unrimed",
"unripe",
"unripened",
"unrivaled",
"unrivalled",
"unromantic",
"unroofed",
"unrouged",
"unruffled",
"unruly",
"unsaddled",
"unsafe",
"unsaid",
"unsalable",
"unsalaried",
"unsaleable",
"unsalted",
"unsanctified",
"unsanctioned",
"unsanded",
"unsanitary",
"unsaponified",
"unsarcastic",
"unsated",
"unsatiable",
"unsatiated",
"unsatisfactory",
"unsatisfiable",
"unsatisfied",
"unsatisfying",
"unsaturated",
"unsaved",
"unsavory",
"unsavoury",
"unscalable",
"unscathed",
"unscheduled",
"unscholarly",
"unschooled",
"unscientific",
"unscripted",
"unscrupulous",
"unsealed",
"unseamanlike",
"unseamed",
"unseasonable",
"unseasoned",
"unseaworthy",
"unsectarian",
"unsecured",
"unseductive",
"unseeable",
"unseeded",
"unseeing",
"unseemly",
"unseen",
"unsegmented",
"unsegregated",
"unselected",
"unselective",
"unselfconscious",
"unselfish",
"unsensational",
"unsent",
"unsentimental",
"unserviceable",
"unservile",
"unsettled",
"unsexed",
"unsexy",
"unshackled",
"unshaded",
"unshadowed",
"unshakable",
"unshaken",
"unshaped",
"unshapely",
"unshapen",
"unshared",
"unsharpened",
"unshaved",
"unshaven",
"unsheared",
"unsheathed",
"unshelled",
"unshielded",
"unshockable",
"unshod",
"unshoed",
"unshorn",
"unshrinkable",
"unshrinking",
"unshuttered",
"unsighted",
"unsightly",
"unsigned",
"unsilenced",
"unsinkable",
"unsized",
"unskilled",
"unskillful",
"unsleeping",
"unsloped",
"unsmiling",
"unsmooth",
"unsmoothed",
"unsnarled",
"unsociable",
"unsocial",
"unsoiled",
"unsold",
"unsoldierly",
"unsolicited",
"unsoluble",
"unsolvable",
"unsolved",
"unsophisticated",
"unsorted",
"unsought",
"unsound",
"unsoundable",
"unsounded",
"unsoured",
"unsown",
"unspaced",
"unsparing",
"unspeakable",
"unspecialised",
"unspecialized",
"unspecific",
"unspecified",
"unspectacular",
"unspent",
"unspoiled",
"unspoilt",
"unspoken",
"unsporting",
"unsportsmanlike",
"unspotted",
"unstable",
"unstaged",
"unstained",
"unstarred",
"unstated",
"unstatesmanlike",
"unsteady",
"unsterilised",
"unsterilized",
"unstilted",
"unstimulating",
"unstinted",
"unstinting",
"unstirred",
"unstoppable",
"unstoppered",
"unstrained",
"unstratified",
"unstressed",
"unstructured",
"unstrung",
"unstuck",
"unstudied",
"unstudious",
"unstylish",
"unsuasible",
"unsubdivided",
"unsubduable",
"unsubdued",
"unsubmissive",
"unsubstantial",
"unsubstantiated",
"unsubtle",
"unsuccessful",
"unsufferable",
"unsugared",
"unsuitable",
"unsuited",
"unsullied",
"unsung",
"unsupervised",
"unsupportable",
"unsupported",
"unsupportive",
"unsuppressed",
"unsure",
"unsurmountable",
"unsurpassable",
"unsurpassed",
"unsurprised",
"unsurprising",
"unsusceptible",
"unsuspected",
"unsuspecting",
"unsuspicious",
"unswayed",
"unsweet",
"unsweetened",
"unswept",
"unswerving",
"unsworn",
"unsyllabic",
"unsyllabled",
"unsymbolic",
"unsymmetric",
"unsymmetrical",
"unsympathetic",
"unsympathising",
"unsympathizing",
"unsynchronised",
"unsynchronized",
"unsynchronous",
"unsystematic",
"untactful",
"untagged",
"untainted",
"untalented",
"untalkative",
"untamed",
"untangled",
"untanned",
"untaped",
"untapped",
"untarnished",
"untasted",
"untaught",
"untaxed",
"untechnical",
"untellable",
"untempered",
"untempting",
"untenable",
"untenanted",
"untended",
"untested",
"untethered",
"unthankful",
"unthawed",
"untheatrical",
"unthematic",
"unthinkable",
"unthinking",
"unthought",
"unthoughtful",
"unthreatening",
"untidy",
"untied",
"untilled",
"untimbered",
"untimely",
"untipped",
"untired",
"untiring",
"untitled",
"untoasted",
"untold",
"untoothed",
"untouchable",
"untouched",
"untoughened",
"untoward",
"untraceable",
"untracked",
"untraditional",
"untrained",
"untrammeled",
"untrammelled",
"untransferable",
"untranslatable",
"untransmutable",
"untraveled",
"untravelled",
"untraversable",
"untraversed",
"untreated",
"untried",
"untrimmed",
"untrod",
"untrodden",
"untroubled",
"untrue",
"untrusting",
"untrustworthy",
"untrusty",
"untruthful",
"untucked",
"untufted",
"untuneful",
"unturned",
"untutored",
"untwisted",
"untypical",
"ununderstood",
"unusable",
"unuseable",
"unused",
"unusual",
"unutterable",
"unuttered",
"unvaccinated",
"unvalued",
"unvaned",
"unvanquishable",
"unvanquished",
"unvaried",
"unvarnished",
"unvarying",
"unveiled",
"unvendible",
"unvented",
"unventilated",
"unverbalised",
"unverbalized",
"unverifiable",
"unverified",
"unversed",
"unvigilant",
"unvindictive",
"unvitrified",
"unvoiced",
"unvoluntary",
"unvulcanised",
"unvulcanized",
"unwanted",
"unwarmed",
"unwarrantable",
"unwarranted",
"unwary",
"unwashed",
"unwatchful",
"unwavering",
"unwaxed",
"unweaned",
"unwearable",
"unwearied",
"unweary",
"unwearying",
"unweathered",
"unwebbed",
"unwed",
"unwedded",
"unwelcome",
"unwell",
"unwholesome",
"unwieldy",
"unwilled",
"unwilling",
"unwise",
"unwished",
"unwitting",
"unwomanly",
"unwonted",
"unwooded",
"unworkable",
"unworkmanlike",
"unworldly",
"unworried",
"unworthy",
"unwounded",
"unwoven",
"unwrapped",
"unwrinkled",
"unwritten",
"unyielding",
"upbeat",
"upbound",
"upcoming",
"upcountry",
"upcurved",
"upended",
"upfield",
"upfront",
"uphill",
"upland",
"uplifted",
"upmarket",
"upmost",
"upper",
"uppercase",
"uppermost",
"uppish",
"uppity",
"upraised",
"upright",
"uproarious",
"upscale",
"upset",
"upsetting",
"upstage",
"upstair",
"upstairs",
"upstanding",
"upstart",
"upstream",
"uptight",
"uptown",
"upturned",
"upward",
"upwind",
"uraemic",
"urban",
"urbane",
"urbanised",
"urbanized",
"urceolate",
"uremic",
"urethral",
"urgent",
"uric",
"uricosuric",
"urinary",
"urogenital",
"ursine",
"uruguayan",
"usable",
"useable",
"used",
"useful",
"useless",
"usual",
"usufructuary",
"usurious",
"uterine",
"utile",
"utilised",
"utilitarian",
"utility",
"utilizable",
"utilized",
"utmost",
"utopian",
"utter",
"utterable",
"uttered",
"uttermost",
"uveal",
"uveous",
"uvular",
"uxorial",
"uxorious",
"uzbekistani",
"vacant",
"vaccinated",
"vacillant",
"vacillating",
"vacuolate",
"vacuolated",
"vacuous",
"vagabond",
"vagal",
"vagile",
"vaginal",
"vagrant",
"vague",
"vain",
"vainglorious",
"valedictory",
"valent",
"valetudinarian",
"valetudinary",
"valiant",
"valid",
"validated",
"validating",
"validatory",
"valorous",
"valuable",
"valued",
"valueless",
"valved",
"valvular",
"vaned",
"vanilla",
"vanished",
"vanquishable",
"vapid",
"vaporific",
"vaporish",
"vaporizable",
"vaporized",
"vaporous",
"vapourific",
"vapourisable",
"vapourised",
"vapourish",
"vapourous",
"variable",
"variant",
"varicelliform",
"varicolored",
"varicoloured",
"varicose",
"varied",
"variegated",
"variform",
"variolar",
"variolic",
"variolous",
"various",
"varnished",
"varying",
"vascular",
"vasiform",
"vasomotor",
"vast",
"vatic",
"vatical",
"vaulted",
"vaulting",
"vedic",
"vegetal",
"vegetational",
"vegetative",
"vegetive",
"vehement",
"vehicular",
"veiled",
"veinal",
"veined",
"veinlike",
"velar",
"velvet",
"velvety",
"venal",
"vendable",
"vendible",
"venerable",
"venerating",
"venereal",
"venetian",
"venezuelan",
"vengeful",
"venial",
"venomed",
"venomous",
"venose",
"venous",
"vented",
"ventilated",
"ventilatory",
"ventral",
"ventricose",
"ventricous",
"ventricular",
"venturesome",
"venturous",
"veracious",
"verbal",
"verbalised",
"verbalized",
"verbatim",
"verbose",
"verboten",
"verdant",
"veridical",
"verifiable",
"verificatory",
"verified",
"verifying",
"verisimilar",
"veritable",
"vermicular",
"vermiculate",
"vermiculated",
"vermiform",
"vermilion",
"vermillion",
"verminous",
"vernacular",
"vernal",
"verrucose",
"versatile",
"versed",
"vertebral",
"vertebrate",
"vertical",
"verticillate",
"verticillated",
"vertiginous",
"very",
"vesical",
"vesicant",
"vesicatory",
"vesicular",
"vestal",
"vested",
"vestiary",
"vestibular",
"vestigial",
"vestmental",
"vestmented",
"veteran",
"veterinary",
"vexatious",
"vexed",
"vexing",
"viable",
"viatical",
"vibrant",
"vibrational",
"vibratory",
"vibrionic",
"vicarial",
"vicarious",
"vicenary",
"vicennial",
"viceregal",
"vicinal",
"vicious",
"victimised",
"victimized",
"victorian",
"victorious",
"viennese",
"vietnamese",
"viewable",
"viewless",
"vigesimal",
"vigilant",
"vigorous",
"viii",
"vile",
"villainous",
"vinaceous",
"vincible",
"vindicated",
"vindicatory",
"vindictive",
"vinegarish",
"vinegary",
"vinous",
"violable",
"violated",
"violative",
"violent",
"violet",
"viral",
"virgin",
"virginal",
"viricidal",
"virile",
"virological",
"virtual",
"virtuoso",
"virtuous",
"virucidal",
"virulent",
"visaged",
"visceral",
"viscid",
"viscoelastic",
"viscometric",
"viscosimetric",
"viscous",
"viselike",
"visible",
"visionary",
"visored",
"visual",
"visualised",
"visualized",
"vital",
"vitalizing",
"vitiated",
"vitiliginous",
"vitreous",
"vitrified",
"vitriolic",
"vituperative",
"vivace",
"vivacious",
"vivid",
"viviparous",
"vixenish",
"vocal",
"vocalic",
"vocational",
"vocative",
"vociferous",
"voguish",
"voiced",
"voiceless",
"void",
"voidable",
"volant",
"volar",
"volatile",
"volatilisable",
"volatilised",
"volatilizable",
"volatilized",
"volcanic",
"volitional",
"voltaic",
"voltarean",
"voltarian",
"voluble",
"volumed",
"volumetric",
"volumetrical",
"voluminous",
"voluntary",
"volunteer",
"voluptuary",
"voluptuous",
"volute",
"voluted",
"voracious",
"voteless",
"votive",
"vowellike",
"voyeuristic",
"voyeuristical",
"vulcanised",
"vulcanized",
"vulgar",
"vulnerable",
"vulpecular",
"vulpine",
"vulturine",
"vulturous",
"vulval",
"vulvar",
"wacky",
"waggish",
"wagnerian",
"wailful",
"wailing",
"wainscoted",
"waiting",
"wakeful",
"wakeless",
"waking",
"walking",
"walleyed",
"walloping",
"wandering",
"waning",
"wanted",
"wanting",
"wanton",
"warlike",
"warm",
"warmed",
"warmhearted",
"warming",
"warning",
"warped",
"warring",
"warriorlike",
"wartlike",
"warty",
"wary",
"washable",
"washed",
"washingtonian",
"washy",
"waspish",
"waste",
"wasted",
"wasteful",
"watchful",
"waterborne",
"watercress",
"watered",
"waterless",
"waterlogged",
"waterproof",
"waterproofed",
"watertight",
"waterworn",
"watery",
"wavelike",
"wavering",
"wavy",
"waxed",
"waxen",
"waxing",
"waxlike",
"waxy",
"wayfaring",
"wayward",
"weak",
"weakened",
"weakening",
"weakly",
"wealthy",
"weaned",
"weaponed",
"weaponless",
"wearable",
"wearied",
"wearing",
"wearisome",
"weary",
"wearying",
"weather",
"weathered",
"weatherly",
"weatherproof",
"weatherworn",
"webbed",
"webby",
"weblike",
"wedded",
"wedged",
"weedless",
"weedy",
"weeklong",
"weekly",
"weensy",
"weeny",
"weeping",
"weepy",
"weighted",
"weightless",
"weighty",
"weird",
"welcome",
"welcoming",
"welfarist",
"well",
"wellborn",
"welsh",
"wesleyan",
"west",
"westbound",
"westerly",
"western",
"westernmost",
"westmost",
"westside",
"westward",
"whacked",
"whacking",
"whacky",
"whatever",
"whatsoever",
"wheaten",
"wheeled",
"wheelless",
"wheezing",
"wheezy",
"whimsical",
"whiney",
"whiny",
"whiplike",
"whipping",
"whippy",
"whirring",
"whiskered",
"whiskerless",
"whiskery",
"whispered",
"whispering",
"white",
"whitened",
"whitewashed",
"whitish",
"whole",
"wholehearted",
"wholemeal",
"wholesale",
"wholesome",
"whopping",
"whorled",
"wiccan",
"wicked",
"wide",
"wideband",
"widespread",
"widowed",
"wieldy",
"wifelike",
"wifely",
"wigged",
"wiggly",
"wigless",
"wild",
"wildcat",
"wilful",
"willful",
"willing",
"willowy",
"wilsonian",
"wilted",
"wily",
"wimpish",
"wimpy",
"windblown",
"windburned",
"windburnt",
"winded",
"winding",
"windless",
"windswept",
"windup",
"windward",
"windy",
"winey",
"winged",
"wingless",
"winglike",
"winking",
"winless",
"winning",
"winsome",
"wintery",
"wintry",
"winy",
"wired",
"wireless",
"wiry",
"wise",
"wishful",
"wisplike",
"wispy",
"wistful",
"witching",
"witchlike",
"withdrawn",
"withered",
"withering",
"witless",
"wittgensteinian",
"witting",
"witty",
"wizard",
"wizardly",
"wizen",
"wizened",
"wobbling",
"wobbly",
"woebegone",
"woeful",
"wolfish",
"wolflike",
"womanish",
"womanlike",
"womanly",
"wonderful",
"wondering",
"wonderworking",
"wondrous",
"wonky",
"wonted",
"wooded",
"wooden",
"woodsy",
"woody",
"woolen",
"woolgathering",
"woollen",
"woolly",
"wooly",
"woozy",
"wordless",
"wordsworthian",
"wordy",
"workable",
"workaday",
"working",
"workmanlike",
"world",
"worldly",
"worldwide",
"wormlike",
"wormy",
"worn",
"worried",
"worrisome",
"worrying",
"worse",
"worsened",
"worsening",
"worshipful",
"worshipped",
"worst",
"worth",
"worthful",
"worthless",
"worthwhile",
"worthy",
"wound",
"wounded",
"wounding",
"woven",
"wraithlike",
"wrapped",
"wrathful",
"wrecked",
"wrenching",
"wretched",
"wriggling",
"wriggly",
"wrinkled",
"wrinkleless",
"wrinkleproof",
"wrinkly",
"writhed",
"writhen",
"writhing",
"written",
"wrong",
"wrongful",
"wrongheaded",
"wroth",
"wrothful",
"wrought",
"wysiwyg",
"xanthous",
"xcii",
"xciii",
"xciv",
"xcvi",
"xcvii",
"xcviii",
"xenogeneic",
"xenophobic",
"xeric",
"xerographic",
"xerophytic",
"xiii",
"xlii",
"xliii",
"xliv",
"xlvi",
"xlvii",
"xlviii",
"xvii",
"xviii",
"xxii",
"xxiii",
"xxiv",
"xxix",
"xxvi",
"xxvii",
"xxviii",
"xxxi",
"xxxii",
"xxxiii",
"xxxiv",
"xxxv",
"xxxvi",
"xxxvii",
"xxxviii",
"yankee",
"yawning",
"yearlong",
"yearly",
"yeastlike",
"yeasty",
"yeatsian",
"yelled",
"yellow",
"yellowed",
"yellowish",
"yemeni",
"yielding",
"yogic",
"yogistic",
"yokelish",
"yonder",
"young",
"younger",
"youngish",
"youthful",
"yucky",
"yugoslav",
"yugoslavian",
"yuman",
"yummy",
"zaftig",
"zairean",
"zairese",
"zambian",
"zany",
"zapotec",
"zealous",
"zenithal",
"zero",
"zeroth",
"zestful",
"zesty",
"zigzag",
"zillion",
"zimbabwean",
"zionist",
"zippy",
"zodiacal",
"zoftig",
"zoic",
"zolaesque",
"zonal",
"zonary",
"zoological",
"zoonotic",
"zoophagous",
"zoroastrian",
"zygodactyl",
"zygomatic",
"zygomorphic",
"zygomorphous",
"zygotic",
"zymoid",
"zymolytic",
"zymotic",
} | adjectives.go | 0.501465 | 0.571587 | adjectives.go | starcoder |
package services
type InstanceTypeBody struct {
InstanceTypes []InstanceType
}
type InstanceType struct {
InstanceType string
VCpuInfo VcpuInfo
MemoryInfo MemoryInfo
}
type VcpuInfo struct {
DefaultVCpus int64
}
type MemoryInfo struct {
SizeInMiB int64
}
func GetInstanceTypesJson() []byte {
return []byte(`
{
"InstanceTypes": [
{
"InstanceType": "m5d.large",
"VCpuInfo": {
"DefaultVCpus": 2
},
"MemoryInfo": {
"SizeInMiB": 8192
}
},
{
"InstanceType": "m5ad.12xlarge",
"VCpuInfo": {
"DefaultVCpus": 48
},
"MemoryInfo": {
"SizeInMiB": 196608
}
},
{
"InstanceType": "c5d.12xlarge",
"VCpuInfo": {
"DefaultVCpus": 48
},
"MemoryInfo": {
"SizeInMiB": 98304
}
},
{
"InstanceType": "m5a.16xlarge",
"VCpuInfo": {
"DefaultVCpus": 64
},
"MemoryInfo": {
"SizeInMiB": 262144
}
},
{
"InstanceType": "m2.4xlarge",
"VCpuInfo": {
"DefaultVCpus": 8
},
"MemoryInfo": {
"SizeInMiB": 70041
}
},
{
"InstanceType": "p3.2xlarge",
"VCpuInfo": {
"DefaultVCpus": 8
},
"MemoryInfo": {
"SizeInMiB": 62464
}
},
{
"InstanceType": "m5d.xlarge",
"VCpuInfo": {
"DefaultVCpus": 4
},
"MemoryInfo": {
"SizeInMiB": 16384
}
},
{
"InstanceType": "c1.xlarge",
"VCpuInfo": {
"DefaultVCpus": 8
},
"MemoryInfo": {
"SizeInMiB": 7168
}
},
{
"InstanceType": "m5.metal",
"VCpuInfo": {
"DefaultVCpus": 96
},
"MemoryInfo": {
"SizeInMiB": 393216
}
},
{
"InstanceType": "r3.8xlarge",
"VCpuInfo": {
"DefaultVCpus": 32
},
"MemoryInfo": {
"SizeInMiB": 249856
},
"EbsInfo": {
"EbsOptimizedSupport": "unsupported",
"EncryptionSupport": "supported"
}
},
{
"InstanceType": "r5a.16xlarge",
"VCpuInfo": {
"DefaultVCpus": 64
},
"MemoryInfo": {
"SizeInMiB": 524288
}
},
{
"InstanceType": "m5ad.8xlarge",
"VCpuInfo": {
"DefaultVCpus": 32
},
"MemoryInfo": {
"SizeInMiB": 131072
}
},
{
"InstanceType": "d2.2xlarge",
"VCpuInfo": {
"DefaultVCpus": 8
},
"MemoryInfo": {
"SizeInMiB": 62464
}
},
{
"InstanceType": "a1.large",
"VCpuInfo": {
"DefaultVCpus": 2
},
"MemoryInfo": {
"SizeInMiB": 4096
}
},
{
"InstanceType": "m5.xlarge",
"VCpuInfo": {
"DefaultVCpus": 4
},
"MemoryInfo": {
"SizeInMiB": 16384
}
},
{
"InstanceType": "m5.12xlarge",
"VCpuInfo": {
"DefaultVCpus": 48,
"ValidCores": [
2,
4,
6,
8,
10,
12,
14,
16,
18,
20,
22,
24
]
},
"MemoryInfo": {
"SizeInMiB": 196608
}
},
{
"InstanceType": "t3a.small",
"VCpuInfo": {
"DefaultVCpus": 2
},
"MemoryInfo": {
"SizeInMiB": 2048
}
},
{
"InstanceType": "r5ad.12xlarge",
"VCpuInfo": {
"DefaultVCpus": 48
},
"MemoryInfo": {
"SizeInMiB": 393216
}
},
{
"InstanceType": "m5.24xlarge",
"VCpuInfo": {
"DefaultVCpus": 96
},
"MemoryInfo": {
"SizeInMiB": 393216
}
},
{
"InstanceType": "r5dn.8xlarge",
"VCpuInfo": {
"DefaultVCpus": 32
},
"MemoryInfo": {
"SizeInMiB": 262144
}
},
{
"InstanceType": "c3.8xlarge",
"VCpuInfo": {
"DefaultVCpus": 32
},
"MemoryInfo": {
"SizeInMiB": 61440
},
"EbsInfo": {
"EbsOptimizedSupport": "unsupported",
"EncryptionSupport": "supported"
}
},
{
"InstanceType": "m4.xlarge",
"VCpuInfo": {
"DefaultVCpus": 4
},
"MemoryInfo": {
"SizeInMiB": 16384
}
},
{
"InstanceType": "m5a.4xlarge",
"VCpuInfo": {
"DefaultVCpus": 16
},
"MemoryInfo": {
"SizeInMiB": 65536
}
},
{
"InstanceType": "c5d.large",
"VCpuInfo": {
"DefaultVCpus": 2
},
"MemoryInfo": {
"SizeInMiB": 4096
}
},
{
"InstanceType": "m5dn.large",
"VCpuInfo": {
"DefaultVCpus": 2
},
"MemoryInfo": {
"SizeInMiB": 8192
}
},
{
"InstanceType": "r5.4xlarge",
"VCpuInfo": {
"DefaultVCpus": 16
},
"MemoryInfo": {
"SizeInMiB": 131072
}
},
{
"InstanceType": "m5dn.xlarge",
"VCpuInfo": {
"DefaultVCpus": 4
},
"MemoryInfo": {
"SizeInMiB": 16384
}
},
{
"InstanceType": "m5dn.2xlarge",
"VCpuInfo": {
"DefaultVCpus": 8
},
"MemoryInfo": {
"SizeInMiB": 32768
}
},
{
"InstanceType": "m5d.16xlarge",
"VCpuInfo": {
"DefaultVCpus": 64
},
"MemoryInfo": {
"SizeInMiB": 262144
}
},
{
"InstanceType": "t1.micro",
"ProcessorInfo": {
"SupportedArchitectures": [
"i386",
"x86_64"
]
},
"VCpuInfo": {
"DefaultVCpus": 1
},
"MemoryInfo": {
"SizeInMiB": 627
}
},
{
"InstanceType": "d2.8xlarge",
"VCpuInfo": {
"DefaultVCpus": 36
},
"MemoryInfo": {
"SizeInMiB": 249856
}
},
{
"InstanceType": "m5dn.8xlarge",
"VCpuInfo": {
"DefaultVCpus": 32
},
"MemoryInfo": {
"SizeInMiB": 131072
}
},
{
"InstanceType": "m5ad.4xlarge",
"VCpuInfo": {
"DefaultVCpus": 16
},
"MemoryInfo": {
"SizeInMiB": 65536
}
},
{
"InstanceType": "g2.2xlarge",
"VCpuInfo": {
"DefaultVCpus": 8
},
"MemoryInfo": {
"SizeInMiB": 15360
},
"GpuInfo": {
"Gpus": [
{
"Name": "K520",
"Manufacturer": "NVIDIA",
"Count": 1,
"MemoryInfo": {
"SizeInMiB": 4096
}
}
],
"TotalGpuMemoryInMiB": 4096
}
},
{
"InstanceType": "c4.4xlarge",
"VCpuInfo": {
"DefaultVCpus": 16
},
"MemoryInfo": {
"SizeInMiB": 30720
}
},
{
"InstanceType": "r5a.large",
"VCpuInfo": {
"DefaultVCpus": 2
},
"MemoryInfo": {
"SizeInMiB": 16384
}
},
{
"InstanceType": "t3.2xlarge",
"VCpuInfo": {
"DefaultVCpus": 8
},
"MemoryInfo": {
"SizeInMiB": 32768
}
},
{
"InstanceType": "c5.4xlarge",
"VCpuInfo": {
"DefaultVCpus": 16
},
"MemoryInfo": {
"SizeInMiB": 32768
}
},
{
"InstanceType": "f1.2xlarge",
"VCpuInfo": {
"DefaultVCpus": 8
},
"MemoryInfo": {
"SizeInMiB": 124928
}
},
{
"InstanceType": "r5.large",
"VCpuInfo": {
"DefaultVCpus": 2
},
"MemoryInfo": {
"SizeInMiB": 16384
}
},
{
"InstanceType": "g3.16xlarge",
"VCpuInfo": {
"DefaultVCpus": 64
},
"MemoryInfo": {
"SizeInMiB": 499712
}
},
{
"InstanceType": "t3a.2xlarge",
"VCpuInfo": {
"DefaultVCpus": 8
},
"MemoryInfo": {
"SizeInMiB": 32768
}
},
{
"InstanceType": "r5n.4xlarge",
"VCpuInfo": {
"DefaultVCpus": 16
},
"MemoryInfo": {
"SizeInMiB": 131072
}
},
{
"InstanceType": "x1e.8xlarge",
"VCpuInfo": {
"DefaultVCpus": 32
},
"MemoryInfo": {
"SizeInMiB": 999424
}
},
{
"InstanceType": "t3.medium",
"VCpuInfo": {
"DefaultVCpus": 2
},
"MemoryInfo": {
"SizeInMiB": 4096
}
},
{
"InstanceType": "c4.large",
"VCpuInfo": {
"DefaultVCpus": 2
},
"MemoryInfo": {
"SizeInMiB": 3840
}
},
{
"InstanceType": "c5d.2xlarge",
"VCpuInfo": {
"DefaultVCpus": 8
},
"MemoryInfo": {
"SizeInMiB": 16384
}
},
{
"InstanceType": "c5.xlarge",
"VCpuInfo": {
"DefaultVCpus": 4
},
"MemoryInfo": {
"SizeInMiB": 8192
}
},
{
"InstanceType": "t3.large",
"VCpuInfo": {
"DefaultVCpus": 2
},
"MemoryInfo": {
"SizeInMiB": 8192
}
},
{
"InstanceType": "m5ad.large",
"VCpuInfo": {
"DefaultVCpus": 2
},
"MemoryInfo": {
"SizeInMiB": 8192
}
},
{
"InstanceType": "r5d.4xlarge",
"VCpuInfo": {
"DefaultVCpus": 16
},
"MemoryInfo": {
"SizeInMiB": 131072
}
},
{
"InstanceType": "m5.8xlarge",
"VCpuInfo": {
"DefaultVCpus": 32
},
"MemoryInfo": {
"SizeInMiB": 131072
}
},
{
"InstanceType": "g3.8xlarge",
"VCpuInfo": {
"DefaultVCpus": 32
},
"MemoryInfo": {
"SizeInMiB": 249856
}
},
{
"InstanceType": "m5dn.12xlarge",
"VCpuInfo": {
"DefaultVCpus": 48
},
"MemoryInfo": {
"SizeInMiB": 196608
}
},
{
"InstanceType": "c5d.24xlarge",
"VCpuInfo": {
"DefaultVCpus": 96
},
"MemoryInfo": {
"SizeInMiB": 196608
}
},
{
"InstanceType": "r4.16xlarge",
"VCpuInfo": {
"DefaultVCpus": 64
},
"MemoryInfo": {
"SizeInMiB": 499712
}
},
{
"InstanceType": "t3a.medium",
"VCpuInfo": {
"DefaultVCpus": 2
},
"MemoryInfo": {
"SizeInMiB": 4096
}
},
{
"InstanceType": "z1d.2xlarge",
"VCpuInfo": {
"DefaultVCpus": 8
},
"MemoryInfo": {
"SizeInMiB": 65536
}
},
{
"InstanceType": "m5ad.2xlarge",
"VCpuInfo": {
"DefaultVCpus": 8
},
"MemoryInfo": {
"SizeInMiB": 32768
}
},
{
"InstanceType": "c3.large",
"ProcessorInfo": {
"SupportedArchitectures": [
"i386",
"x86_64"
],
"SustainedClockSpeedInGhz": 2.8
},
"VCpuInfo": {
"DefaultVCpus": 2
},
"MemoryInfo": {
"SizeInMiB": 3840
},
"EbsInfo": {
"EbsOptimizedSupport": "unsupported",
"EncryptionSupport": "supported"
}
},
{
"InstanceType": "r5n.12xlarge",
"VCpuInfo": {
"DefaultVCpus": 48,
"ValidCores": [
2,
4,
6,
8,
10,
12,
14,
16,
18,
20,
22,
24
]
},
"MemoryInfo": {
"SizeInMiB": 393216
}
},
{
"InstanceType": "r5ad.24xlarge",
"VCpuInfo": {
"DefaultVCpus": 96,
"ValidCores": [
12,
18,
24,
36,
48
]
},
"MemoryInfo": {
"SizeInMiB": 786432
}
},
{
"InstanceType": "h1.8xlarge",
"VCpuInfo": {
"DefaultVCpus": 32
},
"MemoryInfo": {
"SizeInMiB": 131072
}
},
{
"InstanceType": "r3.large",
"VCpuInfo": {
"DefaultVCpus": 2
},
"MemoryInfo": {
"SizeInMiB": 15360
},
"EbsInfo": {
"EbsOptimizedSupport": "unsupported",
"EncryptionSupport": "supported"
}
},
{
"InstanceType": "m5a.2xlarge",
"VCpuInfo": {
"DefaultVCpus": 8
},
"MemoryInfo": {
"SizeInMiB": 32768
}
},
{
"InstanceType": "inf1.xlarge",
"VCpuInfo": {
"DefaultVCpus": 4
},
"MemoryInfo": {
"SizeInMiB": 8192
}
},
{
"InstanceType": "m5d.metal",
"VCpuInfo": {
"DefaultVCpus": 96
},
"MemoryInfo": {
"SizeInMiB": 393216
}
},
{
"InstanceType": "r5ad.8xlarge",
"VCpuInfo": {
"DefaultVCpus": 32
},
"MemoryInfo": {
"SizeInMiB": 262144
}
},
{
"InstanceType": "c1.medium",
"ProcessorInfo": {
"SupportedArchitectures": [
"i386",
"x86_64"
]
},
"VCpuInfo": {
"DefaultVCpus": 2
},
"MemoryInfo": {
"SizeInMiB": 1740
}
},
{
"InstanceType": "c5n.2xlarge",
"VCpuInfo": {
"DefaultVCpus": 8
},
"MemoryInfo": {
"SizeInMiB": 21504
}
},
{
"InstanceType": "m4.4xlarge",
"VCpuInfo": {
"DefaultVCpus": 16
},
"MemoryInfo": {
"SizeInMiB": 65536
}
},
{
"InstanceType": "c4.8xlarge",
"VCpuInfo": {
"DefaultVCpus": 36
},
"MemoryInfo": {
"SizeInMiB": 61440
}
},
{
"InstanceType": "x1.16xlarge",
"VCpuInfo": {
"DefaultVCpus": 64
},
"MemoryInfo": {
"SizeInMiB": 999424
}
},
{
"InstanceType": "g4dn.12xlarge",
"VCpuInfo": {
"DefaultVCpus": 48
},
"MemoryInfo": {
"SizeInMiB": 196608
}
},
{
"InstanceType": "r5a.12xlarge",
"VCpuInfo": {
"DefaultVCpus": 48
},
"MemoryInfo": {
"SizeInMiB": 393216
}
},
{
"InstanceType": "x1e.32xlarge",
"VCpuInfo": {
"DefaultVCpus": 128
},
"MemoryInfo": {
"SizeInMiB": 3997696
}
},
{
"InstanceType": "p2.8xlarge",
"VCpuInfo": {
"DefaultVCpus": 32
},
"MemoryInfo": {
"SizeInMiB": 499712
}
},
{
"InstanceType": "m5d.8xlarge",
"VCpuInfo": {
"DefaultVCpus": 32
},
"MemoryInfo": {
"SizeInMiB": 131072
}
},
{
"InstanceType": "t2.2xlarge",
"VCpuInfo": {
"DefaultVCpus": 8
},
"MemoryInfo": {
"SizeInMiB": 32768
}
},
{
"InstanceType": "t3.xlarge",
"VCpuInfo": {
"DefaultVCpus": 4
},
"MemoryInfo": {
"SizeInMiB": 16384
}
},
{
"InstanceType": "a1.xlarge",
"VCpuInfo": {
"DefaultVCpus": 4
},
"MemoryInfo": {
"SizeInMiB": 8192
}
},
{
"InstanceType": "m2.2xlarge",
"VCpuInfo": {
"DefaultVCpus": 4
},
"MemoryInfo": {
"SizeInMiB": 35020
}
},
{
"InstanceType": "m5n.12xlarge",
"VCpuInfo": {
"DefaultVCpus": 48
},
"MemoryInfo": {
"SizeInMiB": 196608
}
},
{
"InstanceType": "r5a.xlarge",
"VCpuInfo": {
"DefaultVCpus": 4
},
"MemoryInfo": {
"SizeInMiB": 32768
}
},
{
"InstanceType": "a1.medium",
"VCpuInfo": {
"DefaultVCpus": 1
},
"MemoryInfo": {
"SizeInMiB": 2048
}
},
{
"InstanceType": "i2.2xlarge",
"VCpuInfo": {
"DefaultVCpus": 8
},
"MemoryInfo": {
"SizeInMiB": 62464
},
"EbsInfo": {
"EbsOptimizedSupport": "supported",
"EncryptionSupport": "supported"
}
},
{
"InstanceType": "m5n.16xlarge",
"VCpuInfo": {
"DefaultVCpus": 64
},
"MemoryInfo": {
"SizeInMiB": 262144
}
},
{
"InstanceType": "m5n.8xlarge",
"VCpuInfo": {
"DefaultVCpus": 32
},
"MemoryInfo": {
"SizeInMiB": 131072
}
},
{
"InstanceType": "x1e.2xlarge",
"VCpuInfo": {
"DefaultVCpus": 8
},
"MemoryInfo": {
"SizeInMiB": 249856
}
},
{
"InstanceType": "r5.24xlarge",
"VCpuInfo": {
"DefaultVCpus": 96,
"ValidCores": [
4,
6,
8,
10,
12,
14,
16,
18,
20,
22,
24,
26,
28,
30,
32,
34,
36,
38,
40,
42,
44,
46,
48
]
},
"MemoryInfo": {
"SizeInMiB": 786432
}
},
{
"InstanceType": "i3en.12xlarge",
"VCpuInfo": {
"DefaultVCpus": 48,
"ValidCores": [
2,
4,
6,
8,
10,
12,
14,
16,
18,
20,
22,
24
]
},
"MemoryInfo": {
"SizeInMiB": 393216
}
},
{
"InstanceType": "t2.large",
"VCpuInfo": {
"DefaultVCpus": 2
},
"MemoryInfo": {
"SizeInMiB": 8192
}
},
{
"InstanceType": "c5.12xlarge",
"VCpuInfo": {
"DefaultVCpus": 48,
"ValidCores": [
2,
4,
6,
8,
10,
12,
14,
16,
18,
20,
22,
24
]
},
"MemoryInfo": {
"SizeInMiB": 98304
}
},
{
"InstanceType": "i3en.24xlarge",
"VCpuInfo": {
"DefaultVCpus": 96
},
"MemoryInfo": {
"SizeInMiB": 786432
}
},
{
"InstanceType": "c5n.9xlarge",
"VCpuInfo": {
"DefaultVCpus": 36
},
"MemoryInfo": {
"SizeInMiB": 98304
}
},
{
"InstanceType": "c5n.large",
"VCpuInfo": {
"DefaultVCpus": 2
},
"MemoryInfo": {
"SizeInMiB": 5376
}
},
{
"InstanceType": "c5n.4xlarge",
"VCpuInfo": {
"DefaultVCpus": 16
},
"MemoryInfo": {
"SizeInMiB": 43008
}
},
{
"InstanceType": "i3en.3xlarge",
"VCpuInfo": {
"DefaultVCpus": 12,
"ValidCores": [
2,
4,
6
]
},
"MemoryInfo": {
"SizeInMiB": 98304
}
},
{
"InstanceType": "r5a.2xlarge",
"VCpuInfo": {
"DefaultVCpus": 8
},
"MemoryInfo": {
"SizeInMiB": 65536
}
},
{
"InstanceType": "z1d.xlarge",
"VCpuInfo": {
"DefaultVCpus": 4
},
"MemoryInfo": {
"SizeInMiB": 32768
}
},
{
"InstanceType": "i2.4xlarge",
"VCpuInfo": {
"DefaultVCpus": 16
},
"MemoryInfo": {
"SizeInMiB": 124928
},
"EbsInfo": {
"EbsOptimizedSupport": "supported",
"EncryptionSupport": "supported"
}
},
{
"InstanceType": "t2.medium",
"ProcessorInfo": {
"SupportedArchitectures": [
"i386",
"x86_64"
],
"SustainedClockSpeedInGhz": 2.3
},
"VCpuInfo": {
"DefaultVCpus": 2
},
"MemoryInfo": {
"SizeInMiB": 4096
}
},
{
"InstanceType": "c5d.xlarge",
"VCpuInfo": {
"DefaultVCpus": 4
},
"MemoryInfo": {
"SizeInMiB": 8192
}
},
{
"InstanceType": "r5ad.large",
"VCpuInfo": {
"DefaultVCpus": 2
},
"MemoryInfo": {
"SizeInMiB": 16384
}
},
{
"InstanceType": "c5.24xlarge",
"VCpuInfo": {
"DefaultVCpus": 96
},
"MemoryInfo": {
"SizeInMiB": 196608
}
},
{
"InstanceType": "r3.xlarge",
"VCpuInfo": {
"DefaultVCpus": 4
},
"MemoryInfo": {
"SizeInMiB": 31232
},
"EbsInfo": {
"EbsOptimizedSupport": "supported",
"EncryptionSupport": "supported"
}
},
{
"InstanceType": "h1.2xlarge",
"VCpuInfo": {
"DefaultVCpus": 8
},
"MemoryInfo": {
"SizeInMiB": 32768
}
},
{
"InstanceType": "r5n.xlarge",
"VCpuInfo": {
"DefaultVCpus": 4
},
"MemoryInfo": {
"SizeInMiB": 32768
}
},
{
"InstanceType": "m4.16xlarge",
"VCpuInfo": {
"DefaultVCpus": 64
},
"MemoryInfo": {
"SizeInMiB": 262144
}
},
{
"InstanceType": "r5d.large",
"VCpuInfo": {
"DefaultVCpus": 2
},
"MemoryInfo": {
"SizeInMiB": 16384
}
},
{
"InstanceType": "r3.4xlarge",
"VCpuInfo": {
"DefaultVCpus": 16
},
"MemoryInfo": {
"SizeInMiB": 124928
},
"EbsInfo": {
"EbsOptimizedSupport": "supported",
"EncryptionSupport": "supported"
}
},
{
"InstanceType": "r4.xlarge",
"VCpuInfo": {
"DefaultVCpus": 4
},
"MemoryInfo": {
"SizeInMiB": 31232
}
},
{
"InstanceType": "m5n.24xlarge",
"VCpuInfo": {
"DefaultVCpus": 96
},
"MemoryInfo": {
"SizeInMiB": 393216
}
},
{
"InstanceType": "inf1.6xlarge",
"VCpuInfo": {
"DefaultVCpus": 24,
"ValidCores": [
2,
4,
6,
8,
10,
12
]
},
"MemoryInfo": {
"SizeInMiB": 49152
}
},
{
"InstanceType": "c5.large",
"VCpuInfo": {
"DefaultVCpus": 2
},
"MemoryInfo": {
"SizeInMiB": 4096
}
},
{
"InstanceType": "z1d.6xlarge",
"VCpuInfo": {
"DefaultVCpus": 24,
"ValidCores": [
2,
4,
6,
8,
10,
12
]
},
"MemoryInfo": {
"SizeInMiB": 196608
}
},
{
"InstanceType": "r5ad.2xlarge",
"VCpuInfo": {
"DefaultVCpus": 8
},
"MemoryInfo": {
"SizeInMiB": 65536
}
},
{
"InstanceType": "a1.2xlarge",
"VCpuInfo": {
"DefaultVCpus": 8
},
"MemoryInfo": {
"SizeInMiB": 16384
}
},
{
"InstanceType": "inf1.2xlarge",
"VCpuInfo": {
"DefaultVCpus": 8
},
"MemoryInfo": {
"SizeInMiB": 16384
}
},
{
"InstanceType": "m5dn.16xlarge",
"VCpuInfo": {
"DefaultVCpus": 64
},
"MemoryInfo": {
"SizeInMiB": 262144
}
},
{
"InstanceType": "r5.16xlarge",
"VCpuInfo": {
"DefaultVCpus": 64
},
"MemoryInfo": {
"SizeInMiB": 524288
}
},
{
"InstanceType": "r5.12xlarge",
"VCpuInfo": {
"DefaultVCpus": 48,
"ValidCores": [
2,
4,
6,
8,
10,
12,
14,
16,
18,
20,
22,
24
]
},
"MemoryInfo": {
"SizeInMiB": 393216
}
},
{
"InstanceType": "c3.xlarge",
"VCpuInfo": {
"DefaultVCpus": 4
},
"MemoryInfo": {
"SizeInMiB": 7680
},
"EbsInfo": {
"EbsOptimizedSupport": "supported",
"EncryptionSupport": "supported"
}
},
{
"InstanceType": "r5n.2xlarge",
"VCpuInfo": {
"DefaultVCpus": 8
},
"MemoryInfo": {
"SizeInMiB": 65536
}
},
{
"InstanceType": "m5.2xlarge",
"VCpuInfo": {
"DefaultVCpus": 8
},
"MemoryInfo": {
"SizeInMiB": 32768
}
},
{
"InstanceType": "x1e.16xlarge",
"VCpuInfo": {
"DefaultVCpus": 64
},
"MemoryInfo": {
"SizeInMiB": 1998848
}
},
{
"InstanceType": "a1.metal",
"VCpuInfo": {
"DefaultVCpus": 16
},
"MemoryInfo": {
"SizeInMiB": 32768
}
},
{
"InstanceType": "r5a.4xlarge",
"VCpuInfo": {
"DefaultVCpus": 16
},
"MemoryInfo": {
"SizeInMiB": 131072
}
},
{
"InstanceType": "m5.large",
"VCpuInfo": {
"DefaultVCpus": 2
},
"MemoryInfo": {
"SizeInMiB": 8192
}
},
{
"InstanceType": "m4.large",
"VCpuInfo": {
"DefaultVCpus": 2
},
"MemoryInfo": {
"SizeInMiB": 8192
}
},
{
"InstanceType": "z1d.large",
"VCpuInfo": {
"DefaultVCpus": 2
},
"MemoryInfo": {
"SizeInMiB": 16384
}
},
{
"InstanceType": "z1d.metal",
"VCpuInfo": {
"DefaultVCpus": 48
},
"MemoryInfo": {
"SizeInMiB": 393216
}
},
{
"InstanceType": "r5.metal",
"VCpuInfo": {
"DefaultVCpus": 96
},
"MemoryInfo": {
"SizeInMiB": 786432
}
},
{
"InstanceType": "m5d.24xlarge",
"VCpuInfo": {
"DefaultVCpus": 96,
"ValidCores": [
4,
6,
8,
10,
12,
14,
16,
18,
20,
22,
24,
26,
28,
30,
32,
34,
36,
38,
40,
42,
44,
46,
48
]
},
"MemoryInfo": {
"SizeInMiB": 393216
}
},
{
"InstanceType": "t3a.large",
"VCpuInfo": {
"DefaultVCpus": 2
},
"MemoryInfo": {
"SizeInMiB": 8192
}
},
{
"InstanceType": "m5a.8xlarge",
"VCpuInfo": {
"DefaultVCpus": 32
},
"MemoryInfo": {
"SizeInMiB": 131072
}
},
{
"InstanceType": "r5dn.xlarge",
"VCpuInfo": {
"DefaultVCpus": 4
},
"MemoryInfo": {
"SizeInMiB": 32768
}
},
{
"InstanceType": "t2.xlarge",
"VCpuInfo": {
"DefaultVCpus": 4
},
"MemoryInfo": {
"SizeInMiB": 16384
}
},
{
"InstanceType": "c3.4xlarge",
"VCpuInfo": {
"DefaultVCpus": 16
},
"MemoryInfo": {
"SizeInMiB": 30720
},
"EbsInfo": {
"EbsOptimizedSupport": "supported",
"EncryptionSupport": "supported"
}
},
{
"InstanceType": "h1.4xlarge",
"VCpuInfo": {
"DefaultVCpus": 16
},
"MemoryInfo": {
"SizeInMiB": 65536
}
},
{
"InstanceType": "i2.xlarge",
"VCpuInfo": {
"DefaultVCpus": 4
},
"MemoryInfo": {
"SizeInMiB": 31232
},
"EbsInfo": {
"EbsOptimizedSupport": "supported",
"EncryptionSupport": "supported"
}
},
{
"InstanceType": "m5d.12xlarge",
"VCpuInfo": {
"DefaultVCpus": 48,
"ValidCores": [
2,
4,
6,
8,
10,
12,
14,
16,
18,
20,
22,
24
]
},
"MemoryInfo": {
"SizeInMiB": 196608
}
},
{
"InstanceType": "r5dn.12xlarge",
"VCpuInfo": {
"DefaultVCpus": 48,
"ValidCores": [
2,
4,
6,
8,
10,
12,
14,
16,
18,
20,
22,
24
]
},
"MemoryInfo": {
"SizeInMiB": 393216
}
},
{
"InstanceType": "c4.2xlarge",
"VCpuInfo": {
"DefaultVCpus": 8
},
"MemoryInfo": {
"SizeInMiB": 15360
}
},
{
"InstanceType": "c5.metal",
"VCpuInfo": {
"DefaultVCpus": 96
},
"MemoryInfo": {
"SizeInMiB": 196608
}
},
{
"InstanceType": "r5d.metal",
"VCpuInfo": {
"DefaultVCpus": 96
},
"MemoryInfo": {
"SizeInMiB": 786432
}
},
{
"InstanceType": "r5d.xlarge",
"VCpuInfo": {
"DefaultVCpus": 4
},
"MemoryInfo": {
"SizeInMiB": 32768
}
},
{
"InstanceType": "m5dn.4xlarge",
"VCpuInfo": {
"DefaultVCpus": 16
},
"MemoryInfo": {
"SizeInMiB": 65536
}
},
{
"InstanceType": "r5dn.16xlarge",
"VCpuInfo": {
"DefaultVCpus": 64
},
"MemoryInfo": {
"SizeInMiB": 524288
}
},
{
"InstanceType": "m5n.xlarge",
"VCpuInfo": {
"DefaultVCpus": 4
},
"MemoryInfo": {
"SizeInMiB": 16384
}
},
{
"InstanceType": "c5n.metal",
"VCpuInfo": {
"DefaultVCpus": 72
},
"MemoryInfo": {
"SizeInMiB": 196608
}
},
{
"InstanceType": "r5d.8xlarge",
"VCpuInfo": {
"DefaultVCpus": 32
},
"MemoryInfo": {
"SizeInMiB": 262144
}
},
{
"InstanceType": "c5d.4xlarge",
"VCpuInfo": {
"DefaultVCpus": 16
},
"MemoryInfo": {
"SizeInMiB": 32768
}
},
{
"InstanceType": "r4.8xlarge",
"VCpuInfo": {
"DefaultVCpus": 32
},
"MemoryInfo": {
"SizeInMiB": 249856
}
},
{
"InstanceType": "c4.xlarge",
"VCpuInfo": {
"DefaultVCpus": 4
},
"MemoryInfo": {
"SizeInMiB": 7680
}
},
{
"InstanceType": "m3.xlarge",
"VCpuInfo": {
"DefaultVCpus": 4
},
"MemoryInfo": {
"SizeInMiB": 15360
}
},
{
"InstanceType": "r5dn.large",
"VCpuInfo": {
"DefaultVCpus": 2
},
"MemoryInfo": {
"SizeInMiB": 16384
}
},
{
"InstanceType": "r4.2xlarge",
"VCpuInfo": {
"DefaultVCpus": 8
},
"MemoryInfo": {
"SizeInMiB": 62464
}
},
{
"InstanceType": "i3.8xlarge",
"VCpuInfo": {
"DefaultVCpus": 32
},
"MemoryInfo": {
"SizeInMiB": 249856
}
},
{
"InstanceType": "c5n.18xlarge",
"VCpuInfo": {
"DefaultVCpus": 72
},
"MemoryInfo": {
"SizeInMiB": 196608
}
},
{
"InstanceType": "c5d.metal",
"VCpuInfo": {
"DefaultVCpus": 96
},
"MemoryInfo": {
"SizeInMiB": 196608
}
},
{
"InstanceType": "t3.nano",
"VCpuInfo": {
"DefaultVCpus": 2
},
"MemoryInfo": {
"SizeInMiB": 512
}
},
{
"InstanceType": "g4dn.xlarge",
"VCpuInfo": {
"DefaultVCpus": 4
},
"MemoryInfo": {
"SizeInMiB": 16384
}
},
{
"InstanceType": "c5d.18xlarge",
"VCpuInfo": {
"DefaultVCpus": 72,
"ValidCores": [
4,
6,
8,
10,
12,
14,
16,
18,
20,
22,
24,
26,
28,
30,
32,
34,
36
]
},
"MemoryInfo": {
"SizeInMiB": 147456
}
},
{
"InstanceType": "i3.xlarge",
"VCpuInfo": {
"DefaultVCpus": 4
},
"MemoryInfo": {
"SizeInMiB": 31232
}
},
{
"InstanceType": "m4.10xlarge",
"VCpuInfo": {
"DefaultVCpus": 40,
"ValidCores": [
2,
4,
6,
8,
10,
12,
14,
16,
18,
20
]
},
"MemoryInfo": {
"SizeInMiB": 163840
}
},
{
"InstanceType": "g3.4xlarge",
"VCpuInfo": {
"DefaultVCpus": 16
},
"MemoryInfo": {
"SizeInMiB": 124928
}
},
{
"InstanceType": "r5n.24xlarge",
"VCpuInfo": {
"DefaultVCpus": 96
},
"MemoryInfo": {
"SizeInMiB": 786432
}
},
{
"InstanceType": "r5ad.xlarge",
"VCpuInfo": {
"DefaultVCpus": 4
},
"MemoryInfo": {
"SizeInMiB": 32768
}
},
{
"InstanceType": "m4.2xlarge",
"VCpuInfo": {
"DefaultVCpus": 8
},
"MemoryInfo": {
"SizeInMiB": 32768
}
},
{
"InstanceType": "r5.xlarge",
"VCpuInfo": {
"DefaultVCpus": 4
},
"MemoryInfo": {
"SizeInMiB": 32768
}
},
{
"InstanceType": "r5d.2xlarge",
"VCpuInfo": {
"DefaultVCpus": 8
},
"MemoryInfo": {
"SizeInMiB": 65536
}
},
{
"InstanceType": "r5.8xlarge",
"VCpuInfo": {
"DefaultVCpus": 32
},
"MemoryInfo": {
"SizeInMiB": 262144
}
},
{
"InstanceType": "r5n.16xlarge",
"VCpuInfo": {
"DefaultVCpus": 64
},
"MemoryInfo": {
"SizeInMiB": 524288
}
},
{
"InstanceType": "c5.9xlarge",
"VCpuInfo": {
"DefaultVCpus": 36
},
"MemoryInfo": {
"SizeInMiB": 73728
}
},
{
"InstanceType": "t2.micro",
"ProcessorInfo": {
"SupportedArchitectures": [
"i386",
"x86_64"
],
"SustainedClockSpeedInGhz": 2.5
},
"VCpuInfo": {
"DefaultVCpus": 1
},
"MemoryInfo": {
"SizeInMiB": 1024
}
},
{
"InstanceType": "m3.2xlarge",
"VCpuInfo": {
"DefaultVCpus": 8
},
"MemoryInfo": {
"SizeInMiB": 30720
}
},
{
"InstanceType": "m5n.large",
"VCpuInfo": {
"DefaultVCpus": 2
},
"MemoryInfo": {
"SizeInMiB": 8192
}
},
{
"InstanceType": "m5d.2xlarge",
"VCpuInfo": {
"DefaultVCpus": 8
},
"MemoryInfo": {
"SizeInMiB": 32768
}
},
{
"InstanceType": "h1.16xlarge",
"VCpuInfo": {
"DefaultVCpus": 64
},
"MemoryInfo": {
"SizeInMiB": 262144
}
},
{
"InstanceType": "r5.2xlarge",
"VCpuInfo": {
"DefaultVCpus": 8
},
"MemoryInfo": {
"SizeInMiB": 65536
}
},
{
"InstanceType": "r5d.24xlarge",
"VCpuInfo": {
"DefaultVCpus": 96,
"ValidCores": [
4,
6,
8,
10,
12,
14,
16,
18,
20,
22,
24,
26,
28,
30,
32,
34,
36,
38,
40,
42,
44,
46,
48
]
},
"MemoryInfo": {
"SizeInMiB": 786432
}
},
{
"InstanceType": "r5d.16xlarge",
"VCpuInfo": {
"DefaultVCpus": 64
},
"MemoryInfo": {
"SizeInMiB": 524288
}
},
{
"InstanceType": "i3.16xlarge",
"VCpuInfo": {
"DefaultVCpus": 64
},
"MemoryInfo": {
"SizeInMiB": 499712
}
},
{
"InstanceType": "r5ad.16xlarge",
"VCpuInfo": {
"DefaultVCpus": 64
},
"MemoryInfo": {
"SizeInMiB": 524288
}
},
{
"InstanceType": "i3.large",
"VCpuInfo": {
"DefaultVCpus": 2
},
"MemoryInfo": {
"SizeInMiB": 15616
}
},
{
"InstanceType": "r3.2xlarge",
"VCpuInfo": {
"DefaultVCpus": 8
},
"MemoryInfo": {
"SizeInMiB": 62464
},
"EbsInfo": {
"EbsOptimizedSupport": "supported",
"EncryptionSupport": "supported"
}
},
{
"InstanceType": "c5.2xlarge",
"VCpuInfo": {
"DefaultVCpus": 8
},
"MemoryInfo": {
"SizeInMiB": 16384
}
},
{
"InstanceType": "z1d.12xlarge",
"VCpuInfo": {
"DefaultVCpus": 48,
"ValidCores": [
4,
6,
8,
10,
12,
14,
16,
18,
20,
22,
24
]
},
"MemoryInfo": {
"SizeInMiB": 393216
}
},
{
"InstanceType": "m5.16xlarge",
"VCpuInfo": {
"DefaultVCpus": 64
},
"MemoryInfo": {
"SizeInMiB": 262144
}
},
{
"InstanceType": "m5.4xlarge",
"VCpuInfo": {
"DefaultVCpus": 16
},
"MemoryInfo": {
"SizeInMiB": 65536
}
},
{
"InstanceType": "m1.xlarge",
"VCpuInfo": {
"DefaultVCpus": 4
},
"MemoryInfo": {
"SizeInMiB": 15360
}
},
{
"InstanceType": "m5ad.xlarge",
"VCpuInfo": {
"DefaultVCpus": 4
},
"MemoryInfo": {
"SizeInMiB": 16384
}
},
{
"InstanceType": "t3.micro",
"VCpuInfo": {
"DefaultVCpus": 2
},
"MemoryInfo": {
"SizeInMiB": 1024
}
},
{
"InstanceType": "a1.4xlarge",
"VCpuInfo": {
"DefaultVCpus": 16,
"ValidCores": [
16
]
},
"MemoryInfo": {
"SizeInMiB": 32768
}
},
{
"InstanceType": "m5ad.24xlarge",
"VCpuInfo": {
"DefaultVCpus": 96,
"ValidCores": [
12,
18,
24,
36,
48
]
},
"MemoryInfo": {
"SizeInMiB": 393216
}
},
{
"InstanceType": "c3.2xlarge",
"VCpuInfo": {
"DefaultVCpus": 8
},
"MemoryInfo": {
"SizeInMiB": 15360
},
"EbsInfo": {
"EbsOptimizedSupport": "supported",
"EncryptionSupport": "supported"
}
},
{
"InstanceType": "m5n.4xlarge",
"VCpuInfo": {
"DefaultVCpus": 16
},
"MemoryInfo": {
"SizeInMiB": 65536
}
},
{
"InstanceType": "i2.8xlarge",
"VCpuInfo": {
"DefaultVCpus": 32
},
"MemoryInfo": {
"SizeInMiB": 249856
},
"EbsInfo": {
"EbsOptimizedSupport": "unsupported",
"EncryptionSupport": "supported"
}
},
{
"InstanceType": "m5dn.24xlarge",
"VCpuInfo": {
"DefaultVCpus": 96
},
"MemoryInfo": {
"SizeInMiB": 393216
}
},
{
"InstanceType": "r5d.12xlarge",
"VCpuInfo": {
"DefaultVCpus": 48,
"ValidCores": [
2,
4,
6,
8,
10,
12,
14,
16,
18,
20,
22,
24
]
},
"MemoryInfo": {
"SizeInMiB": 393216
}
},
{
"InstanceType": "c5d.9xlarge",
"VCpuInfo": {
"DefaultVCpus": 36
},
"MemoryInfo": {
"SizeInMiB": 73728
}
},
{
"InstanceType": "g4dn.16xlarge",
"VCpuInfo": {
"DefaultVCpus": 64
},
"MemoryInfo": {
"SizeInMiB": 262144
}
},
{
"InstanceType": "f1.16xlarge",
"VCpuInfo": {
"DefaultVCpus": 64
},
"MemoryInfo": {
"SizeInMiB": 999424
}
},
{
"InstanceType": "r5a.8xlarge",
"VCpuInfo": {
"DefaultVCpus": 32
},
"MemoryInfo": {
"SizeInMiB": 262144
}
},
{
"InstanceType": "r5n.large",
"VCpuInfo": {
"DefaultVCpus": 2
},
"MemoryInfo": {
"SizeInMiB": 16384
}
},
{
"InstanceType": "inf1.24xlarge",
"VCpuInfo": {
"DefaultVCpus": 96
},
"MemoryInfo": {
"SizeInMiB": 196608
}
},
{
"InstanceType": "i3en.large",
"VCpuInfo": {
"DefaultVCpus": 2
},
"MemoryInfo": {
"SizeInMiB": 16384
}
},
{
"InstanceType": "f1.4xlarge",
"VCpuInfo": {
"DefaultVCpus": 16
},
"MemoryInfo": {
"SizeInMiB": 249856
}
},
{
"InstanceType": "g3s.xlarge",
"VCpuInfo": {
"DefaultVCpus": 4
},
"MemoryInfo": {
"SizeInMiB": 31232
}
},
{
"InstanceType": "p2.xlarge",
"VCpuInfo": {
"DefaultVCpus": 4
},
"MemoryInfo": {
"SizeInMiB": 62464
}
},
{
"InstanceType": "d2.4xlarge",
"VCpuInfo": {
"DefaultVCpus": 16
},
"MemoryInfo": {
"SizeInMiB": 124928
}
},
{
"InstanceType": "m1.large",
"VCpuInfo": {
"DefaultVCpus": 2
},
"MemoryInfo": {
"SizeInMiB": 7680
}
},
{
"InstanceType": "r5dn.24xlarge",
"VCpuInfo": {
"DefaultVCpus": 96
},
"MemoryInfo": {
"SizeInMiB": 786432
}
},
{
"InstanceType": "r5a.24xlarge",
"VCpuInfo": {
"DefaultVCpus": 96
},
"MemoryInfo": {
"SizeInMiB": 786432
}
},
{
"InstanceType": "r5ad.4xlarge",
"VCpuInfo": {
"DefaultVCpus": 16
},
"MemoryInfo": {
"SizeInMiB": 131072
}
},
{
"InstanceType": "i3en.2xlarge",
"VCpuInfo": {
"DefaultVCpus": 8
},
"MemoryInfo": {
"SizeInMiB": 65536
}
},
{
"InstanceType": "i3.metal",
"VCpuInfo": {
"DefaultVCpus": 72
},
"MemoryInfo": {
"SizeInMiB": 524288
}
},
{
"InstanceType": "t3.small",
"VCpuInfo": {
"DefaultVCpus": 2
},
"MemoryInfo": {
"SizeInMiB": 2048
}
},
{
"InstanceType": "r5n.8xlarge",
"VCpuInfo": {
"DefaultVCpus": 32
},
"MemoryInfo": {
"SizeInMiB": 262144
}
},
{
"InstanceType": "p3dn.24xlarge",
"VCpuInfo": {
"DefaultVCpus": 96,
"ValidCores": [
4,
6,
8,
10,
12,
14,
16,
18,
20,
22,
24,
26,
28,
30,
32,
34,
36,
38,
40,
42,
44,
46,
48
]
},
"MemoryInfo": {
"SizeInMiB": 786432
}
},
{
"InstanceType": "r4.4xlarge",
"VCpuInfo": {
"DefaultVCpus": 16
},
"MemoryInfo": {
"SizeInMiB": 124928
}
},
{
"InstanceType": "m3.medium",
"VCpuInfo": {
"DefaultVCpus": 1
},
"MemoryInfo": {
"SizeInMiB": 3840
}
},
{
"InstanceType": "m5a.24xlarge",
"VCpuInfo": {
"DefaultVCpus": 96,
"ValidCores": [
12,
18,
24,
36,
48
]
},
"MemoryInfo": {
"SizeInMiB": 393216
}
},
{
"InstanceType": "x1.32xlarge",
"VCpuInfo": {
"DefaultVCpus": 128,
"ValidCores": [
4,
8,
12,
16,
20,
24,
28,
32,
36,
40,
44,
48,
52,
56,
60,
64
]
},
"MemoryInfo": {
"SizeInMiB": 1998848
}
},
{
"InstanceType": "m5d.4xlarge",
"VCpuInfo": {
"DefaultVCpus": 16
},
"MemoryInfo": {
"SizeInMiB": 65536
}
},
{
"InstanceType": "r4.large",
"VCpuInfo": {
"DefaultVCpus": 2
},
"MemoryInfo": {
"SizeInMiB": 15616
}
},
{
"InstanceType": "c5.18xlarge",
"VCpuInfo": {
"DefaultVCpus": 72
},
"MemoryInfo": {
"SizeInMiB": 147456
}
},
{
"InstanceType": "g4dn.4xlarge",
"VCpuInfo": {
"DefaultVCpus": 16
},
"MemoryInfo": {
"SizeInMiB": 65536
}
},
{
"InstanceType": "r5dn.2xlarge",
"VCpuInfo": {
"DefaultVCpus": 8
},
"MemoryInfo": {
"SizeInMiB": 65536
}
},
{
"InstanceType": "cc2.8xlarge",
"VCpuInfo": {
"DefaultVCpus": 32
},
"MemoryInfo": {
"SizeInMiB": 61952
},
"EbsInfo": {
"EbsOptimizedSupport": "unsupported",
"EncryptionSupport": "unsupported"
}
},
{
"InstanceType": "i3en.6xlarge",
"VCpuInfo": {
"DefaultVCpus": 24,
"ValidCores": [
2,
4,
6,
8,
10,
12
]
},
"MemoryInfo": {
"SizeInMiB": 196608
}
},
{
"InstanceType": "i3en.metal",
"VCpuInfo": {
"DefaultVCpus": 96
},
"MemoryInfo": {
"SizeInMiB": 786432
}
},
{
"InstanceType": "m1.medium",
"ProcessorInfo": {
"SupportedArchitectures": [
"i386",
"x86_64"
]
},
"VCpuInfo": {
"DefaultVCpus": 1
},
"MemoryInfo": {
"SizeInMiB": 3788
}
},
{
"InstanceType": "g4dn.2xlarge",
"VCpuInfo": {
"DefaultVCpus": 8
},
"MemoryInfo": {
"SizeInMiB": 32768
}
},
{
"InstanceType": "m5a.xlarge",
"VCpuInfo": {
"DefaultVCpus": 4
},
"MemoryInfo": {
"SizeInMiB": 16384
}
},
{
"InstanceType": "t2.nano",
"ProcessorInfo": {
"SupportedArchitectures": [
"i386",
"x86_64"
],
"SustainedClockSpeedInGhz": 2.4
},
"VCpuInfo": {
"DefaultVCpus": 1
},
"MemoryInfo": {
"SizeInMiB": 512
}
},
{
"InstanceType": "i3en.xlarge",
"VCpuInfo": {
"DefaultVCpus": 4
},
"MemoryInfo": {
"SizeInMiB": 32768
}
},
{
"InstanceType": "m1.small",
"VCpuInfo": {
"DefaultVCpus": 1
},
"MemoryInfo": {
"SizeInMiB": 1740
}
},
{
"InstanceType": "m5a.12xlarge",
"VCpuInfo": {
"DefaultVCpus": 48
},
"MemoryInfo": {
"SizeInMiB": 196608
}
},
{
"InstanceType": "x1e.4xlarge",
"VCpuInfo": {
"DefaultVCpus": 16
},
"MemoryInfo": {
"SizeInMiB": 499712
}
},
{
"InstanceType": "d2.xlarge",
"VCpuInfo": {
"DefaultVCpus": 4
},
"MemoryInfo": {
"SizeInMiB": 31232
}
},
{
"InstanceType": "p3.16xlarge",
"VCpuInfo": {
"DefaultVCpus": 64
},
"MemoryInfo": {
"SizeInMiB": 499712
}
},
{
"InstanceType": "r5dn.4xlarge",
"VCpuInfo": {
"DefaultVCpus": 16
},
"MemoryInfo": {
"SizeInMiB": 131072
}
},
{
"InstanceType": "t3a.nano",
"VCpuInfo": {
"DefaultVCpus": 2
},
"MemoryInfo": {
"SizeInMiB": 512
}
},
{
"InstanceType": "t3a.xlarge",
"VCpuInfo": {
"DefaultVCpus": 4
},
"MemoryInfo": {
"SizeInMiB": 16384
}
},
{
"InstanceType": "t2.small",
"ProcessorInfo": {
"SupportedArchitectures": [
"i386",
"x86_64"
],
"SustainedClockSpeedInGhz": 2.5
},
"VCpuInfo": {
"DefaultVCpus": 1
},
"MemoryInfo": {
"SizeInMiB": 2048
}
},
{
"InstanceType": "t3a.micro",
"VCpuInfo": {
"DefaultVCpus": 2
},
"MemoryInfo": {
"SizeInMiB": 1024
}
},
{
"InstanceType": "i3.4xlarge",
"VCpuInfo": {
"DefaultVCpus": 16
},
"MemoryInfo": {
"SizeInMiB": 124928
}
},
{
"InstanceType": "m5n.2xlarge",
"VCpuInfo": {
"DefaultVCpus": 8
},
"MemoryInfo": {
"SizeInMiB": 32768
}
},
{
"InstanceType": "p2.16xlarge",
"VCpuInfo": {
"DefaultVCpus": 64
},
"MemoryInfo": {
"SizeInMiB": 749568
}
},
{
"InstanceType": "m5ad.16xlarge",
"VCpuInfo": {
"DefaultVCpus": 64
},
"MemoryInfo": {
"SizeInMiB": 262144
}
},
{
"InstanceType": "i3.2xlarge",
"VCpuInfo": {
"DefaultVCpus": 8
},
"MemoryInfo": {
"SizeInMiB": 62464
}
},
{
"InstanceType": "z1d.3xlarge",
"VCpuInfo": {
"DefaultVCpus": 12
},
"MemoryInfo": {
"SizeInMiB": 98304
}
},
{
"InstanceType": "m2.xlarge",
"VCpuInfo": {
"DefaultVCpus": 2
},
"MemoryInfo": {
"SizeInMiB": 17510
}
},
{
"InstanceType": "c5n.xlarge",
"VCpuInfo": {
"DefaultVCpus": 4
},
"MemoryInfo": {
"SizeInMiB": 10752
}
},
{
"InstanceType": "g2.8xlarge",
"VCpuInfo": {
"DefaultVCpus": 32
},
"MemoryInfo": {
"SizeInMiB": 61440
}
},
{
"InstanceType": "p3.8xlarge",
"VCpuInfo": {
"DefaultVCpus": 32
},
"MemoryInfo": {
"SizeInMiB": 249856
}
},
{
"InstanceType": "x1e.xlarge",
"VCpuInfo": {
"DefaultVCpus": 4
},
"MemoryInfo": {
"SizeInMiB": 124928
}
},
{
"InstanceType": "m3.large",
"VCpuInfo": {
"DefaultVCpus": 2
},
"MemoryInfo": {
"SizeInMiB": 7680
}
},
{
"InstanceType": "g4dn.8xlarge",
"VCpuInfo": {
"DefaultVCpus": 32
},
"MemoryInfo": {
"SizeInMiB": 131072
}
},
{
"InstanceType": "m5a.large",
"VCpuInfo": {
"DefaultVCpus": 2
},
"MemoryInfo": {
"SizeInMiB": 8192
}
}
]
}
`)
} | services/InstanceTypes.go | 0.521227 | 0.439386 | InstanceTypes.go | starcoder |
package main
import (
"image"
"image/color"
"math"
"sync"
)
// A Vec3 represents three-component vector.
type Vec3 [3]float64
// Length returns length (magnitude) of x.
func (x *Vec3) Length() float64 {
return math.Sqrt(x.Length2())
}
// Length2 returns squared length of x.
func (x *Vec3) Length2() float64 {
return x.Dot(x)
}
// Normalize sets z to normalized vector of x, and returns it.
func (z *Vec3) Normalize(x *Vec3) *Vec3 {
return z.Scale(x, 1.0/x.Length())
}
// Add sets component-wize sum of x and y to z, and returns it.
func (z *Vec3) Add(x, y *Vec3) *Vec3 {
for i, _ := range z {
z[i] = x[i] + y[i]
}
return z
}
// Sub sets component-wize difference of x and y to z, and returns it.
func (z *Vec3) Sub(x, y *Vec3) *Vec3 {
for i, _ := range z {
z[i] = x[i] - y[i]
}
return z
}
// Scale sets scalar multiplication of x and y to z, and returns it.
func (z *Vec3) Scale(x *Vec3, y float64) *Vec3 {
for i, _ := range z {
z[i] = x[i] * y
}
return z
}
// Dot returns dot product of x and y.
func (x *Vec3) Dot(y *Vec3) float64 {
z := float64(0)
for i, _ := range z {
z += x[i] * y[i]
}
return z
}
// Cross sets cross product of x and y to z, and returns it.
func (z *Vec3) Cross(x, y *Vec3) *Vec3 {
z[0] = x[1]*y[2] - x[2]*y[1]
z[1] = x[2]*y[0] - x[0]*y[2]
z[2] = x[0]*y[1] - x[1]*y[0]
return z
}
type Scene struct {
Objects []Object
Camera *Camera
}
func (s Scene) Render() {
var wg sync.WaitGroup
img := s.Camera.Film.Image
b := img.Bounds()
for x := b.Min.X; x < b.Max.X; x++ {
for y := b.Min.Y; y < b.Max.Y; y++ {
wg.Add(1)
go func(x, y) {
defer wg.Done()
c := img.At(x, y)
for i := 0; i < s.Camera.Config.Samples; i++ {
// TODO: Generate ray
var ray Ray
r1, g1, b1, a1 := c.RGBA()
r2, g2, b2, a2 := trace(ray, 0)
c := colors.RGBA{
R: r1 + r2,
G: g1 + g2,
B: b1 + b2,
A: a1 + a2,
}
img.Set(x, y, c)
}
}(x, y)
}
}
wg.Wait()
}
func (s Scene) trace(r Ray, d int) color.Color {
}
type Camera struct {
Position *Vec3
Direction *Vec3
Config *CameraConfig
}
type CameraConfig struct {
Film Film
FocalLen float64
Samples int
}
type Film struct {
Image image.Image
Height float64
Width float64
}
type Object interface {
Expose(Ray) *Intersection
}
type Ray struct {
Origin *Vec3
Direction *Vec3
}
func NewRayThrough(a, b) Ray {
return Ray{}
}
type Intersection struct {
Position *Vec3
Normal *Vec3
Material Material
}
type Material interface{}
type Plane struct {
Center *Vec3
Normal *Vec3
Material Material
}
func (p Plane) Expose(r Ray) Intersection {
dn := r.Direction.Dot(p.Normal)
if 0 < dn {
return nil
}
v := Vec3{}
v.Sub(r.Origin, p.Center)
vn := v.Dot(p.Normal)
t := vn / dn * -1
if t < 0 {
return nil
}
return Intersection{
Position: &t,
Normal: p.Normal,
Material: p.Material,
}
}
type Sphere struct {
Center *Vec3
Radius float64
Material Material
}
func (s Sphere) Expose(r Ray) Intersection {
v := Vec3{}
v.Sub(r.Origin, p.Center)
d2 := math.Pow(v.Dot(r.Direction), 2) - (v.Length2() - math.Pow(s.Radius, 2))
if d < 0 {
return nil
}
d := math.Sqrt(d2)
t1 := -1*b - d
t2 := -1*b + d
if 0 < t1 {
return s.intersection(r, t1)
}
if 0 < t2 {
return s.intersection(r, t2)
}
return nil
}
func (s Sphere) intersection(r Ray, t float64) *Intersection {
d := r.Direction.Scale(t)
p := Vec3{}
p.Add(r.Origin, d)
n := Vec3{}
n.Sub(p, s.Center)
n.Normalize(n)
return &Intersection{
Position: t,
Normal: n,
Material: s.Material,
}
}
func main() {
} | 2018/2018090701/main.go | 0.747708 | 0.547646 | main.go | starcoder |
package riksbank
import (
"time"
"github.com/zeeraw/riksbank/currency"
"github.com/zeeraw/riksbank/period"
)
// RateGroup represents a group for a rate
type RateGroup struct {
ID string
Name string
}
// RateSeries represents a series for a rate
type RateSeries struct {
ID string
Name string
}
// Rate represents a interest or exchange series rate for a period
type Rate struct {
Group RateGroup
Series RateSeries
Date time.Time
Period period.Period
Value *float64
}
// Rates represents multiple instances of Rate
type Rates []Rate
// Day represents information about a specific day in banking context
type Day struct {
Date time.Time
Year int
Week int
IsBankDay bool
}
// Days represents multiple instances of Day
type Days []Day
// Group represents information about an interest and exchange rate grouping
type Group struct {
ID string
ParentID string
Name string
Description string
}
// Groups represents multiple instances of Group
type Groups []Group
// ExchangeRate represents an exchange rate between two currencies
type ExchangeRate struct {
Date time.Time
Period period.Period
Base currency.Currency
Counter currency.Currency
Value *float64
}
// ExchangeRates represents multiple instance of ExchangeRate
type ExchangeRates []ExchangeRate
// ExchangeCurrency represents the exchange information for a currency
type ExchangeCurrency struct {
SeriesID string
Code string
Currency currency.Currency
Description string
}
// ExchangeCurrencies represents multiple instances of ExchangeCurrency
type ExchangeCurrencies []ExchangeCurrency
// Series represents information about a series
type Series struct {
ID string
GroupID string
Name string
Description string
LongDescription string
Source string
From time.Time
To time.Time
}
// SeriesGroup represents a group of series and information about the group
type SeriesGroup struct {
Group Group
Series []Series
}
// SeriesGroups represent multiple instances of SeriesGroup
type SeriesGroups []SeriesGroup | types.go | 0.581778 | 0.674339 | types.go | starcoder |
package compiler
import (
"fmt"
"ok/ast"
"ok/instruction"
"ok/lexer"
"strings"
)
func getBinaryInstruction(op string, left, right, result string) (instruction.Instruction, string) {
switch op {
case "data + data":
return &instruction.Combine{Left: left, Right: right, Result: result}, "data"
case "data += data":
return &instruction.Combine{Left: left, Right: right, Result: left}, "data"
case "number + number":
return &instruction.Add{Left: left, Right: right, Result: result}, "number"
case "number += number":
return &instruction.Add{Left: left, Right: right, Result: left}, "number"
case "number - number":
return &instruction.Subtract{Left: left, Right: right, Result: result}, "number"
case "number -= number":
return &instruction.Subtract{Left: left, Right: right, Result: left}, "number"
case "number * number":
return &instruction.Multiply{Left: left, Right: right, Result: result}, "number"
case "number *= number":
return &instruction.Multiply{Left: left, Right: right, Result: left}, "number"
case "number / number":
return &instruction.Divide{Left: left, Right: right, Result: result}, "number"
case "number /= number":
return &instruction.Divide{Left: left, Right: right, Result: left}, "number"
case "number % number":
return &instruction.Remainder{Left: left, Right: right, Result: result}, "number"
case "number %= number":
return &instruction.Remainder{Left: left, Right: right, Result: left}, "number"
case "string + string":
return &instruction.Concat{Left: left, Right: right, Result: result}, "string"
case "string += string":
return &instruction.Concat{Left: left, Right: right, Result: left}, "string"
case "bool and bool":
return &instruction.And{Left: left, Right: right, Result: result}, "bool"
case "bool or bool":
return &instruction.Or{Left: left, Right: right, Result: result}, "bool"
case "bool == bool", "char == char", "data == data", "string == string":
return &instruction.Equal{Left: left, Right: right, Result: result}, "bool"
case "number == number":
return &instruction.EqualNumber{Left: left, Right: right, Result: result}, "bool"
case "bool != bool", "char != char", "data != data", "string != string":
return &instruction.NotEqual{Left: left, Right: right, Result: result}, "bool"
case "number != number":
return &instruction.NotEqualNumber{Left: left, Right: right, Result: result}, "bool"
case "number > number":
return &instruction.GreaterThanNumber{Left: left, Right: right, Result: result}, "bool"
case "string > string":
return &instruction.GreaterThanString{Left: left, Right: right, Result: result}, "bool"
case "number < number":
return &instruction.LessThanNumber{Left: left, Right: right, Result: result}, "bool"
case "string < string":
return &instruction.LessThanString{Left: left, Right: right, Result: result}, "bool"
case "number >= number":
return &instruction.GreaterThanEqualNumber{Left: left, Right: right, Result: result}, "bool"
case "string >= string":
return &instruction.GreaterThanEqualString{Left: left, Right: right, Result: result}, "bool"
case "number <= number":
return &instruction.LessThanEqualNumber{Left: left, Right: right, Result: result}, "bool"
case "string <= string":
return &instruction.LessThanEqualString{Left: left, Right: right, Result: result}, "bool"
}
return nil, ""
}
func compileBinary(compiledFunc *CompiledFunc, node *ast.Binary) (string, string, error) {
if node.Op == lexer.TokenAssign ||
node.Op == lexer.TokenPlusAssign ||
node.Op == lexer.TokenMinusAssign ||
node.Op == lexer.TokenTimesAssign ||
node.Op == lexer.TokenDivideAssign ||
node.Op == lexer.TokenRemainderAssign {
right, rightKind, err := compileExpr(compiledFunc, node.Right)
if err != nil {
return "", "", err
}
// TODO(elliot): Check +=, etc.
if key, ok := node.Left.(*ast.Key); ok {
arrayOrMapResult, arrayOrMapKind, err := compileExpr(compiledFunc, key.Expr)
if err != nil {
return "", "", err
}
// TODO(elliot): Check this is a sane operation.
keyResult, _, err := compileExpr(compiledFunc, key.Key)
if err != nil {
return "", "", err
}
if strings.HasPrefix(arrayOrMapKind, "[]") {
ins := &instruction.ArraySet{
Array: arrayOrMapResult,
Index: keyResult,
Value: right,
}
compiledFunc.append(ins)
} else {
ins := &instruction.MapSet{
Map: arrayOrMapResult,
Key: keyResult,
Value: right,
}
compiledFunc.append(ins)
}
// TODO(elliot): Return something more reasonable here.
return "", "", nil
}
variable, ok := node.Left.(*ast.Identifier)
if !ok {
return "", "", fmt.Errorf("cannot assign to non-variable")
}
// Make sure we do not assign the wrong type to an existing variable.
if v, ok := compiledFunc.variables[variable.Name]; ok && rightKind != v {
return "", "", fmt.Errorf(
"cannot assign %s to variable %s (expecting %s)",
rightKind, variable.Name, v)
}
returns := right
if node.Op != lexer.TokenAssign {
returns = compiledFunc.nextRegister()
}
switch node.Op {
case lexer.TokenPlusAssign:
switch rightKind {
case "data":
compiledFunc.append(&instruction.Combine{
Left: variable.Name,
Right: right,
Result: returns,
})
case "number":
compiledFunc.append(&instruction.Add{
Left: variable.Name,
Right: right,
Result: returns,
})
case "string":
compiledFunc.append(&instruction.Concat{
Left: variable.Name,
Right: right,
Result: returns,
})
}
case lexer.TokenMinusAssign:
compiledFunc.append(&instruction.Subtract{
Left: variable.Name,
Right: right,
Result: returns,
})
case lexer.TokenTimesAssign:
compiledFunc.append(&instruction.Multiply{
Left: variable.Name,
Right: right,
Result: returns,
})
case lexer.TokenDivideAssign:
compiledFunc.append(&instruction.Divide{
Left: variable.Name,
Right: right,
Result: returns,
})
case lexer.TokenRemainderAssign:
compiledFunc.append(&instruction.Remainder{
Left: variable.Name,
Right: right,
Result: returns,
})
}
ins := &instruction.Assign{
VariableName: variable.Name,
Register: returns,
}
compiledFunc.append(ins)
compiledFunc.variables[variable.Name] = rightKind
return variable.Name, rightKind, nil
}
left, leftKind, err := compileExpr(compiledFunc, node.Left)
if err != nil {
return "", "", err
}
right, rightKind, err := compileExpr(compiledFunc, node.Right)
if err != nil {
return "", "", err
}
returns := compiledFunc.nextRegister()
op := fmt.Sprintf("%s %s %s", leftKind, node.Op, rightKind)
if bop, kind := getBinaryInstruction(op, left, right, returns); bop != nil {
// TODO(elliot): It would be nice to be able to evaluate expressions
// involving literals here. So, 1 + 1 just becomes 2.
compiledFunc.append(bop)
return returns, kind, nil
}
return "", "", fmt.Errorf("cannot perform %s", op)
} | compiler/binary.go | 0.5794 | 0.582075 | binary.go | starcoder |
package main
import (
"fmt"
"math"
"strings"
"time"
)
const Tau = 2 * math.Pi
func DegToRad(deg float64) float64 {
return deg * Tau / 360
}
func RadToDeg(rad float64) float64 {
return rad * 360 / Tau
}
// func DegToRad(deg float64) float64 {
// return deg * math.Pi / 180
// }
// func RadToDeg(rad float64) float64 {
// return rad * 180 / math.Pi
// }
func clampFloat64(a float64, min, max float64) float64 {
if max < min { // empty range
return 0
}
if a < min {
a = min
}
if a > max {
a = max
}
return a
}
func ceilPowerOfTwo(x int) int {
d := 1
for d < x {
d *= 2
}
return d
}
var (
//angleNormalize = angleNormalizeV1
angleNormalize = angleNormalizeV2
)
// [-Pi, +Pi)
func angleNormalizeV1(angle float64) float64 {
for angle < -math.Pi {
angle += Tau
}
for angle >= math.Pi {
angle -= Tau
}
return angle
}
// a % b
func modFloat64(a, b float64) float64 {
m := a - math.Floor(a/b)*b
if m < 0 {
m += b
}
return m
}
func angleNormalizeV2(angle float64) float64 {
angle += math.Pi
// [0, 2*Pi) = [0, Tau)
angle = modFloat64(angle, Tau)
//angle = math.Mod(angle, Tau)
angle -= math.Pi
return angle
}
// Lerp - Linear interpolation
// t= [0..1]
// (t == 0) => v0
// (t == 1) => v1
func lerp(v0, v1 float64, t float64) float64 {
return (1.0-t)*v0 + t*v1
}
func mod(x, y int) int {
m := x % y
if m < 0 {
m += y
}
return m
}
func checkMax(prefix string, x, max float64) {
if math.Abs(x) > max {
err := fmt.Errorf("%s: %v", prefix, x)
panic(err)
}
}
const (
minVelocity = -1e+20
maxVelocity = +1e+20
)
func clampVelocity(velocity float64) float64 {
return clampFloat64(velocity, minVelocity, maxVelocity)
}
//------------------------------------------------------------------------------
var (
//strCat = strCat1
strCat = strCat2
)
func strCat1(vs ...string) string {
var b strings.Builder
for _, v := range vs {
b.WriteString(v)
}
return b.String()
}
func strCat2(vs ...string) string {
return strings.Join(vs, "")
}
//------------------------------------------------------------------------------
var (
// time.RFC3339 - "2006-01-02T15:04:05"
dateTimeFormat = strCat(
"2006", "01", "02", // date (YYYYMMDD)
"15", "04", "05", // time (HHMMSS)
)
)
func makeFilename(prefix, extention string) string {
st := time.Now().Format(dateTimeFormat)
return prefix + st + extention
} | doublepend/util.go | 0.692954 | 0.479321 | util.go | starcoder |
package bitops
import "fmt"
// real implementation for Extract32 and GetField32
func extract32(value uint32, start uint, length uint) (uint32, error) {
return (value >> start) & ( ^uint32(0) >> (32 - length)), nil
}
// real implementation for Extract64 and GetField64
func extract64(value uint64, start uint, length uint) (uint64, error) {
return (value >> start) & ( ^uint64(0) >> (64 - length)), nil
}
// Extract32 specify field from uint32 by staring position and length
// LSB/MSB are 0/31 and return original value if error occurs
func Extract32(value uint32, start uint, length uint) (uint32, error) {
if (start > 31 || length > 32 - start ) {
return value, fmt.Errorf("invalid start(%v) or length(%v)", start, length);
}
return extract32(value, start, length)
}
// Extract64 specify field from uint64 by starting position and length
// LSB/MSB are 0/63 and return original value if error occurs
func Extract64(value uint64, start uint, length uint) (uint64, error) {
if (start > 63 || length > 64 - start ) {
return value, fmt.Errorf("invalid start(%v) or length(%v)", start, length);
}
return extract64(value, start, length)
}
// GetField32 specify field between high and low bit from uint32
// LSB/MSB are 0/31 and return original value if error occurs
func GetField32(value uint32, high uint, low uint) (uint32, error) {
if (high > 31 || low > 31 || high < low) {
return value, fmt.Errorf("invalid high(%v) or low(%v)", high, low);
}
return extract32(value, low, high - low + 1)
}
// GetField64 specify field between high and low bit from uint64
// LSB/MSB are 0/63 and return original value if error occurs
func GetField64(value uint64, high uint, low uint) (uint64, error) {
if (high > 63 || low > 63 || high < low) {
return value, fmt.Errorf("invalid high(%v) or low(%v)", high, low);
}
return extract64(value, low, high - low + 1)
}
// real implementation for Depoit32 and SetField32
func deposit32(value uint32, start uint, length uint, field uint32) (uint32, error) {
mask := (^uint32(0) >> (32 - length)) << start;
return (value & ^mask) | ((field << start) & mask), nil;
}
// real implementation for Depoit64 and SetField64
func deposit64(value uint64, start uint, length uint, field uint64) (uint64, error) {
mask := (^uint64(0) >> (64 - length)) << start;
return (value & ^mask) | ((field << start) & mask), nil;
}
// Deposit32 specified field to uint32 variable by staring position and length
// LSB/MSB are 0/31 and return original value if error occurs
func Deposit32(value uint32, start uint, length uint, field uint32) (uint32, error) {
if start > 31 || length > 32 - start {
return value, fmt.Errorf("invalid start(%v) or length(%v)", start, length);
}
return deposit32(value, start, length, field)
}
// Deposit64 specified field to uint64 variable by staring position and length
// LSB/MSB are 0/63 and return original value if error occurs
func Deposit64(value uint64, start uint, length uint, field uint64) (uint64, error) {
if start > 63 || length > 64 - start {
return value, fmt.Errorf("invalid start(%v) or length(%v)", start, length);
}
return deposit64(value, start, length, field)
}
// SetField32 specified field to uint32 variable by staring position and length
// LSB/MSB are 0/31 and return original value if error occurs
func SetField32(value uint32, high uint, low uint, field uint32) (uint32, error) {
if high > 31 || low > 31 || high < low {
return value, fmt.Errorf("invalid high(%v) or low(%v)", high, low);
}
return deposit32(value, low, high - low + 1, field)
}
// SetField64 specified field to uint64 variable by staring position and length
// LSB/MSB are 0/63 and return original value if error occurs
func SetField64(value uint64, high uint, low uint, field uint64) (uint64, error) {
if high > 63 || low > 63 || high < low {
return value, fmt.Errorf("invalid high(%v) or low(%v)", high, low);
}
return deposit64(value, low, high - low + 1, field)
}
// CountOne8 return number of 1 in uint8 variable
func CountOne8(value uint8) (uint) {
value = (value & 0x55) + ((value >> 1) & 0x55);
value = (value & 0x33) + ((value >> 2) & 0x33);
value = (value & 0x0f) + ((value >> 4) & 0x0f);
return uint(value);
}
// CountOne16 return number of 1 in uint16 variable
func CountOne16(value uint16) (uint) {
value = (value & 0x5555) + ((value >> 1) & 0x5555);
value = (value & 0x3333) + ((value >> 2) & 0x3333);
value = (value & 0x0f0f) + ((value >> 4) & 0x0f0f);
value = (value & 0x00ff) + ((value >> 8) & 0x00ff);
return uint(value);
}
// CountOne32 return number of 1 in uint32 variable
func CountOne32(value uint32) (uint) {
value = (value & 0x55555555) + ((value >> 1) & 0x55555555);
value = (value & 0x33333333) + ((value >> 2) & 0x33333333);
value = (value & 0x0f0f0f0f) + ((value >> 4) & 0x0f0f0f0f);
value = (value & 0x00ff00ff) + ((value >> 8) & 0x00ff00ff);
value = (value & 0x0000ffff) + ((value >> 16) & 0x0000ffff);
return uint(value);
}
// CountOne64 return number of 1 in uint64 variable
func CountOne64(value uint64) (uint) {
value = (value & 0x5555555555555555) + ((value >> 1) & 0x5555555555555555);
value = (value & 0x3333333333333333) + ((value >> 2) & 0x3333333333333333);
value = (value & 0x0f0f0f0f0f0f0f0f) + ((value >> 4) & 0x0f0f0f0f0f0f0f0f);
value = (value & 0x00ff00ff00ff00ff) + ((value >> 8) & 0x00ff00ff00ff00ff);
value = (value & 0x0000ffff0000ffff) + ((value >> 16) & 0x0000ffff0000ffff);
value = (value & 0x00000000ffffffff) + ((value >> 32) & 0x00000000ffffffff);
return uint(value);
}
// CountOne8 return number of 0 in uint8 variable
func CountZero8(value uint8) (uint) {
return 8 - CountOne8(value)
}
// CountOne16 return number of 0 in uint16 variable
func CountZero16(value uint16) (uint) {
return 16 - CountOne16(value)
}
// CountOne32 return number of 0 in uint32 variable
func CountZero32(value uint32) (uint) {
return 32 - CountOne32(value)
}
// CountOne64 return number of 0 in uint64 variable
func CountZero64(value uint64) (uint) {
return 64 - CountOne64(value)
}
// CountTrailZero32 return number of trailing zero in a 32-bit value
func CountTrailZero32(value uint32) (uint) {
var count uint = 0
if (value & 0x0000FFFF) == 0 {
count += 16;
value >>= 16;
}
if (value & 0x000000FF) == 0 {
count += 8;
value >>= 8;
}
if (value & 0x0000000F) == 0 {
count += 4;
value >>= 4;
}
if (value & 0x00000003) == 0 {
count += 2;
value >>= 2;
}
if (value & 0x00000001) == 0 {
count++;
value >>= 1;
}
if (value & 0x00000001) == 0 {
count++;
}
return count
}
// CountTrailZero64 return number of trailing zero in a 32-bit value
func CountTrailZero64(value uint64) (uint) {
var count uint = 0
if uint32(value) == 0 {
count += 32;
value >>= 32;
}
return count + CountTrailZero32(uint32(value))
}
// CountTrailOne32 return number of trailing 1 in a 32-bit value
func CountTrailOne32(value uint32) (uint) {
return CountTrailZero32(^value)
}
// CountTrailOne64 return number of trailing 1 in a 32-bit value
func CountTrailOne64(value uint64) (uint) {
return CountTrailZero64(^value)
}
// CountLeadZero32 return number of leading 0 in a 32-bit value
func CountLeadZero32(value uint32) (uint) {
var count uint = 0
if (value & 0xFFFF0000) == 0 {
count += 16;
value <<= 16;
}
if (value & 0xFF000000) == 0 {
count += 8;
value <<= 8;
}
if (value & 0xF0000000) == 0 {
count += 4;
value <<= 4;
}
if (value & 0x30000000) == 0 {
count += 2;
value <<= 2;
}
if (value & 0x10000000) == 0 {
count++;
value <<= 1;
}
if (value & 0x10000000) == 0 {
count++;
}
return count
}
// CountLeadZero64 return number of leading 0 in a 32-bit value
func CountLeadZero64(value uint64) (uint) {
var count uint = 0
if (value >> 32) == 0 {
count += 32
} else {
value >>= 32;
}
return count + CountLeadZero32(uint32(value))
}
// CountLeadOne32 return number of leading 1 in a 32-bit value
func CountLeadOne32(value uint32) (uint) {
return CountLeadZero32(^value)
}
// CountLeadOne64 return number of leading 1 in a 32-bit value
func CountLeadOne64(value uint64) (uint) {
return CountLeadZero64(^value)
}
// SetBit32 set the specified bit to 1 for 32-bit value and return the new value
func SetBit32(value uint32, pos uint) (uint32, error) {
if pos >= 32 {
return value, fmt.Errorf("invalid position(%v)", pos)
}
return (value | (uint32(1) << pos)), nil
}
// SetBit64 set the specified bit to 1 for 64-bit value and return the new value
func SetBit64(value uint64, pos uint) (uint64, error) {
if pos >= 64 {
return value, fmt.Errorf("invalid position(%v)", pos)
}
return (value | (uint64(1) << pos)), nil
}
// ToggleBit32 set the specified bit to 1 for 32-bit value and return the new value
func ToggleBit32(value uint32, pos uint) (uint32, error) {
if pos >= 32 {
return value, fmt.Errorf("invalid position(%v)", pos)
}
return (value ^ (uint32(1) << pos)), nil
}
// ToggleBit64 set the specified bit to 1 for 64-bit value and return the new value
func ToggleBit64(value uint64, pos uint) (uint64, error) {
if pos >= 64 {
return value, fmt.Errorf("invalid position(%v)", pos)
}
return (value ^ (uint64(1) << pos)), nil
}
// ClearBit32 set the specified bit to 1 for 32-bit value and return the new value
func ClearBit32(value uint32, pos uint) (uint32, error) {
if pos >= 32 {
return value, fmt.Errorf("invalid position(%v)", pos)
}
return (value &^ (uint32(1) << pos)), nil
}
// ClearBit64 set the specified bit to 1 for 64-bit value and return the new value
func ClearBit64(value uint64, pos uint) (uint64, error) {
if pos >= 64 {
return value, fmt.Errorf("invalid position(%v)", pos)
}
return (value &^ (uint64(1) << pos)), nil
}
// TestBit32 set the specified bit to 1 for 32-bit value and return the new value
func TestBit32(value uint32, pos uint) (bool, error) {
if pos >= 32 {
return false, fmt.Errorf("invalid position(%v)", pos)
}
return (value & (uint32(1) << pos)) != 0, nil
}
// TestBit64 set the specified bit to 1 for 64-bit value and return the new value
func TestBit64(value uint64, pos uint) (bool, error) {
if pos >= 64 {
return false, fmt.Errorf("invalid position(%v)", pos)
}
return (value & (uint64(1) << pos)) != 0, nil
}
// Reverse32 set reverse the bit order for 32-bit variable
func Reverse32(value uint32) (uint32) {
value = ((value >> 1) & 0x55555555) | ((value & 0x55555555) << 1)
value = ((value >> 2) & 0x33333333) | ((value & 0x33333333) << 2)
value = ((value >> 4) & 0x0F0F0F0F) | ((value & 0x0F0F0F0F) << 4)
value = ((value >> 8) & 0x00FF00FF) | ((value & 0x00FF00FF) << 8)
value = ( value >> 16 ) | ( value << 16)
return value
}
// Reverse64 set reverse the bit order for 64-bit variable
func Reverse64(value uint64) (uint64) {
high := Reverse32(uint32(value))
low := Reverse32(uint32(value >> 32))
return (uint64(high) << 32) | uint64(low)
}
// RotateRight32 rotate an 32-bit value right
func RotateRight32(value uint32, shift uint) (uint32) {
shift = shift & 0x1F
return (value >> shift) | (value << (32 - shift))
}
// RotateLeft32 rotate an 32-bit value left
func RotateLeft32(value uint32, shift uint) (uint32){
shift = shift & 0x1F
return (value << shift) | (value >> (32 - shift))
}
// RotateRight64 rotate an 64-bit value right
func RotateRight64(value uint64, shift uint) (uint64){
shift = shift & 0x3F
return (value >> shift) | (value << (64 - shift))
}
// RotateLeft64 rotate an 64-bit value left
func RotateLeft64(value uint64, shift uint) (uint64){
shift = shift & 0x3F
return (value << shift) | (value >> (64 - shift))
} | bitops.go | 0.636918 | 0.542984 | bitops.go | starcoder |
// In some languages it's idiomatic to use [generic](http://en.wikipedia.org/wiki/Generic_programming)
// data structures and algorithms. Go does not support
// generics; in Go it's common to provide collection
// functions if and when they are specifically needed for
// your program and data types.
// Here are some example collection functions for slices
// of `strings`. You can use these examples to build your
// own functions. Note that in some cases it may be
// clearest to just inline the collection-manipulating
// code directly, instead of creating and calling a
// helper function.
package main
import "strings"
import "fmt"
// Index returns the first index of the target string `t`, or
// -1 if no match is found.
func Index(vs []string, t string) int {
for i, v := range vs {
if v == t {
return i
}
}
return -1
}
// Include returns `true` if the target string t is in the
// slice.
func Include(vs []string, t string) bool {
return Index(vs, t) >= 0
}
// Any returns `true` if one of the strings in the slice
// satisfies the predicate `f`.
func Any(vs []string, f func(string) bool) bool {
for _, v := range vs {
if f(v) {
return true
}
}
return false
}
// All returns `true` if all of the strings in the slice
// satisfy the predicate `f`.
func All(vs []string, f func(string) bool) bool {
for _, v := range vs {
if !f(v) {
return false
}
}
return true
}
// Filter returns a new slice containing all strings in the
// slice that satisfy the predicate `f`.
func Filter(vs []string, f func(string) bool) []string {
vsf := make([]string, 0)
for _, v := range vs {
if f(v) {
vsf = append(vsf, v)
}
}
return vsf
}
// Map returns a new slice containing the results of applying
// the function `f` to each string in the original slice.
func Map(vs []string, f func(string) string) []string {
vsm := make([]string, len(vs))
for i, v := range vs {
vsm[i] = f(v)
}
return vsm
}
func main() {
// Here we try out our various collection functions.
var strs = []string{"peach", "apple", "pear", "plum"}
fmt.Println(Index(strs, "pear"))
fmt.Println(Include(strs, "grape"))
fmt.Println(Any(strs, func(v string) bool {
return strings.HasPrefix(v, "p")
}))
fmt.Println(All(strs, func(v string) bool {
return strings.HasPrefix(v, "p")
}))
fmt.Println(Filter(strs, func(v string) bool {
return strings.Contains(v, "e")
}))
// The above examples all used anonymous functions,
// but you can also use named functions of the correct
// type.
fmt.Println(Map(strs, strings.ToUpper))
} | collection-function.go | 0.823612 | 0.578002 | collection-function.go | starcoder |
// Interface to ws2811 chip (neopixel driver). Make sure that you have
// ws2811.h and pwm.h in a GCC include path (e.g. /usr/local/include) and
// libws2811.a in a GCC library path (e.g. /usr/local/lib).
// See https://github.com/jgarff/rpi_ws281x for instructions
package ws2811
import "github.com/pkg/errors"
const (
// DefaultDmaNum is the default DMA number.
DefaultDmaNum = 10
// RpiPwmChannels is the number of PWM leds in the Raspberry Pi
RpiPwmChannels = 2
// TargetFreq is the target frequency. It is usually 800kHz (800000), and an go as low as 400000
TargetFreq = 800000
// DefaultGpioPin is the default pin on the Raspberry Pi where the signal will be available. Note
// that it is the BCM (Broadcom Pin Number) and the "Pin" 18 is actually the physical pin 12 of the
// Raspberry Pi.
DefaultGpioPin = 18
// DefaultLedCount is the default number of LEDs on the stripe.
DefaultLedCount = 16
// DefaultBrightness is the default maximum brightness of the LEDs. The brightness value can be between 0 and 255.
// If the brightness is too low, the LEDs remain dark. If the brightness is too high, the system needs too much
// current.
DefaultBrightness = 64 // Safe value between 0 and 255.
)
const (
// HwVerTypeUnknown represents unknown hardware
HwVerTypeUnknown = 0
// HwVerTypePi1 represents the Raspberry Pi 1
HwVerTypePi1 = 1
// HwVerTypePi2 represents the Raspberry Pi 2
HwVerTypePi2 = 2
)
// StateDesc is a map from a return state to its string description.
//nolint: gochecknoglobals
var StateDesc = map[int]string{
0: "Success",
-1: "Generic failure",
-2: "Out of memory",
-3: "Hardware revision is not supported",
-4: "Memory lock failed",
-5: "mmap() failed",
-6: "Unable to map registers into userspace",
-7: "Unable to initialize GPIO",
-8: "Unable to initialize PWM",
-9: "Failed to create mailbox device",
-10: "DMA error",
-11: "Selected GPIO not possible",
-12: "Unable to initialize PCM",
-13: "Unable to initialize SPI",
-14: "SPI transfer error",
}
// HwDesc is the Hardware Description
type HwDesc struct {
Type uint32
Version uint32
PeriphBase uint32
VideocoreBase uint32
Desc string
}
// ChannelOption is the list of channel options
type ChannelOption struct {
// GpioPin is the GPIO Pin with PWM alternate function, 0 if unused
GpioPin int
// Invert inverts output signal
Invert bool
// LedCount is the number of LEDs, 0 if channel is unused
LedCount int
// StripeType is the strip color layout -- one of WS2811StripXXX constants
StripeType int
// Brightness is the maximum brightness of the LEDs. Value between 0 and 255
Brightness int
// WShift is the white shift value
WShift int
// RShift is the red shift value
RShift int
// GShift is the green shift value
GShift int
// BShift is blue shift value
BShift int
// Gamma is the gamma correction table
Gamma []byte
}
// Option is the list of device options
type Option struct {
// RenderWaitTime is the time in µs before the next render can run
RenderWaitTime int
// Frequency is the required output frequency
Frequency int
// DmaNum is the number of a DMA _not_ already in use
DmaNum int
// Channels are channel options
Channels []ChannelOption
}
// DefaultOptions defines sensible default options for MakeWS2811
//nolint: gochecknoglobals
var DefaultOptions = Option{
Frequency: TargetFreq,
DmaNum: DefaultDmaNum,
Channels: []ChannelOption{
{
GpioPin: DefaultGpioPin,
LedCount: DefaultLedCount,
Brightness: DefaultBrightness,
StripeType: WS2812Strip,
Invert: false,
Gamma: gamma8,
},
},
}
// Leds returns the LEDs array of a given channel
func (ws2811 *WS2811) Leds(channel int) []uint32 {
return ws2811.leds[channel]
}
// SetLedsSync wait for the frame to finish and replace all the LEDs
func (ws2811 *WS2811) SetLedsSync(channel int, leds []uint32) error {
if err := ws2811.Wait(); err != nil {
return errors.WithMessage(err, "Error setting LEDs")
}
l := len(leds)
if l > len(ws2811.leds[channel]) {
return errors.New("Error: Too many LEDs")
}
for i := 0; i < l; i++ {
ws2811.leds[channel][i] = leds[i]
}
return nil
}
// StatusDesc returns the description of a status code
func StatusDesc(code int) string {
desc, ok := StateDesc[code]
if ok {
return desc
}
return "Unknown"
} | ws2811.go | 0.575588 | 0.410402 | ws2811.go | starcoder |
package assert
import (
"fmt"
"testing"
"github.com/slcjordan/poc"
)
type ListGames struct {
assertion *Assertion
cursorLimitCheckers []Int32Checker
cursorOffsetCheckers []Int32Checker
Games SavedGameSummaryArray1D
}
func newListGames(assertion *Assertion) ListGames {
return ListGames{
assertion: assertion,
Games: newSavedGameSummaryArray1D(assertion),
}
}
func (parent *ListGames) CursorLimit(checkers ...Int32Checker) *Assertion {
parent.cursorLimitCheckers = checkers
return parent.assertion
}
func (parent *ListGames) CursorOffset(checkers ...Int32Checker) *Assertion {
parent.cursorOffsetCheckers = checkers
return parent.assertion
}
func (parent *ListGames) CheckListGames(t *testing.T, desc string, val poc.ListGames) {
for _, checker := range parent.cursorLimitCheckers {
checker.CheckInt32(t, desc+".Cursor.Limit", val.Cursor.Limit)
}
for _, checker := range parent.cursorOffsetCheckers {
checker.CheckInt32(t, desc+".Cursor.Offset", val.Cursor.Offset)
}
parent.Games.CheckSavedGameSummaryArray1D(t, desc+".Games", val.Games)
}
type PerformMove struct {
assertion *Assertion
Next MoveArray1D
SavedGameDetail SavedGameDetail
}
func newPerformMove(assertion *Assertion) PerformMove {
return PerformMove{
assertion: assertion,
Next: newMoveArray1D(assertion),
SavedGameDetail: newSavedGameDetail(assertion),
}
}
func (parent *PerformMove) CheckPerformMove(t *testing.T, desc string, val poc.PerformMove) {
parent.Next.CheckMoveArray1D(t, desc+".Next", val.Next)
parent.SavedGameDetail.CheckSavedGameDetail(t, desc+".SavedGameDetail", val.SavedGameDetail)
}
type SavedGameDetail struct {
assertion *Assertion
gameIDCheckers []Int64Checker
Board Board
History MoveArray2D
PossibleNextMoves MoveArray2D
Variant Variant
}
func newSavedGameDetail(assertion *Assertion) SavedGameDetail {
return SavedGameDetail{
assertion: assertion,
Board: newBoard(assertion),
History: newMoveArray2D(assertion),
PossibleNextMoves: newMoveArray2D(assertion),
Variant: newVariant(assertion),
}
}
func (parent *SavedGameDetail) GameID(checkers ...Int64Checker) *Assertion {
parent.gameIDCheckers = checkers
return parent.assertion
}
func (parent *SavedGameDetail) CheckSavedGameDetail(t *testing.T, desc string, val poc.SavedGameDetail) {
for _, checker := range parent.gameIDCheckers {
checker.CheckInt64(t, desc+".GameID", val.GameID)
}
parent.Board.CheckBoard(t, desc+".Board", val.Board)
parent.History.CheckMoveArray2D(t, desc+".History", val.History)
parent.PossibleNextMoves.CheckMoveArray2D(t, desc+".PossibleNextMoves", val.PossibleNextMoves)
parent.Variant.CheckVariant(t, desc+".Variant", val.Variant)
}
type SavedGameSummary struct {
assertion *Assertion
gameIDCheckers []Int64Checker
scoreCheckers []Int32Checker
}
func newSavedGameSummary(assertion *Assertion) SavedGameSummary {
return SavedGameSummary{
assertion: assertion,
}
}
func (parent *SavedGameSummary) GameID(checkers ...Int64Checker) *Assertion {
parent.gameIDCheckers = checkers
return parent.assertion
}
func (parent *SavedGameSummary) Score(checkers ...Int32Checker) *Assertion {
parent.scoreCheckers = checkers
return parent.assertion
}
func (parent *SavedGameSummary) CheckSavedGameSummary(t *testing.T, desc string, val poc.SavedGameSummary) {
for _, checker := range parent.gameIDCheckers {
checker.CheckInt64(t, desc+".GameID", val.GameID)
}
for _, checker := range parent.scoreCheckers {
checker.CheckInt32(t, desc+".Score", val.Score)
}
}
type StartGame struct {
assertion *Assertion
SavedGameDetail SavedGameDetail
Variant Variant
}
func newStartGame(assertion *Assertion) StartGame {
return StartGame{
assertion: assertion,
SavedGameDetail: newSavedGameDetail(assertion),
Variant: newVariant(assertion),
}
}
func (parent *StartGame) CheckStartGame(t *testing.T, desc string, val poc.StartGame) {
parent.SavedGameDetail.CheckSavedGameDetail(t, desc+".SavedGameDetail", val.SavedGameDetail)
parent.Variant.CheckVariant(t, desc+".Variant", val.Variant)
}
type SavedGameSummaryArray1D struct {
assertion *Assertion
lengthCheckers []IntChecker
nth map[int]SavedGameSummary
ForEach SavedGameSummary
}
func newSavedGameSummaryArray1D(assertion *Assertion) SavedGameSummaryArray1D {
return SavedGameSummaryArray1D{
assertion: assertion,
nth: make(map[int]SavedGameSummary),
ForEach: newSavedGameSummary(assertion),
}
}
func (a *SavedGameSummaryArray1D) Nth(i int) SavedGameSummary {
prev, ok := a.nth[i]
if ok {
return prev
}
result := newSavedGameSummary(a.assertion)
a.nth[i] = result
return result
}
func (a *SavedGameSummaryArray1D) Length(checkers ...IntChecker) *Assertion {
a.lengthCheckers = checkers
return a.assertion
}
func (a *SavedGameSummaryArray1D) CheckSavedGameSummaryArray1D(t *testing.T, desc string, val []poc.SavedGameSummary) {
for _, checker := range a.lengthCheckers {
checker.CheckInt(t, desc+".length", len(val))
}
for i, checker := range a.nth {
checker.CheckSavedGameSummary(t, desc+fmt.Sprintf("[%d]", i), val[i])
}
for _, curr := range val {
a.ForEach.CheckSavedGameSummary(t, desc+".ForEach", curr)
}
}
type MoveArray1D struct {
assertion *Assertion
lengthCheckers []IntChecker
nth map[int]Move
ForEach Move
}
func newMoveArray1D(assertion *Assertion) MoveArray1D {
return MoveArray1D{
assertion: assertion,
nth: make(map[int]Move),
ForEach: newMove(assertion),
}
}
func (a *MoveArray1D) Nth(i int) Move {
prev, ok := a.nth[i]
if ok {
return prev
}
result := newMove(a.assertion)
a.nth[i] = result
return result
}
func (a *MoveArray1D) Length(checkers ...IntChecker) *Assertion {
a.lengthCheckers = checkers
return a.assertion
}
func (a *MoveArray1D) CheckMoveArray1D(t *testing.T, desc string, val []poc.Move) {
for _, checker := range a.lengthCheckers {
checker.CheckInt(t, desc+".length", len(val))
}
for i, checker := range a.nth {
checker.CheckMove(t, desc+fmt.Sprintf("[%d]", i), val[i])
}
for _, curr := range val {
a.ForEach.CheckMove(t, desc+".ForEach", curr)
}
}
type MoveArray2D struct {
assertion *Assertion
lengthCheckers []IntChecker
nth map[int]MoveArray1D
ForEach MoveArray1D
}
func newMoveArray2D(assertion *Assertion) MoveArray2D {
return MoveArray2D{
assertion: assertion,
nth: make(map[int]MoveArray1D),
ForEach: newMoveArray1D(assertion),
}
}
func (a *MoveArray2D) Nth(i int) MoveArray1D {
prev, ok := a.nth[i]
if ok {
return prev
}
result := newMoveArray1D(a.assertion)
a.nth[i] = result
return result
}
func (a *MoveArray2D) Length(checkers ...IntChecker) *Assertion {
a.lengthCheckers = checkers
return a.assertion
}
func (a *MoveArray2D) CheckMoveArray2D(t *testing.T, desc string, val [][]poc.Move) {
for _, checker := range a.lengthCheckers {
checker.CheckInt(t, desc+".length", len(val))
}
for i, checker := range a.nth {
checker.CheckMoveArray1D(t, desc+fmt.Sprintf("[%d]", i), val[i])
}
for _, curr := range val {
a.ForEach.CheckMoveArray1D(t, desc+".ForEach", curr)
}
} | test/assert/service.go | 0.658308 | 0.639117 | service.go | starcoder |
package mapval
import (
"fmt"
"strings"
"time"
"github.com/stretchr/testify/assert"
)
// KeyPresent checks that the given key is in the map, even if it has a nil value.
var KeyPresent = IsDef{name: "check key present"}
// KeyMissing checks that the given key is not present defined.
var KeyMissing = IsDef{name: "check key not present", checkKeyMissing: true}
// IsAny takes a variable number of IsDef's and combines them with a logical OR. If any single definition
// matches the key will be marked as valid.
func IsAny(of ...IsDef) IsDef {
names := make([]string, len(of))
for i, def := range of {
names[i] = def.name
}
isName := fmt.Sprintf("either %#v", names)
return Is(isName, func(v interface{}) ValueResult {
for _, def := range of {
vr := def.check(v, true)
if vr.Valid {
return vr
}
}
return ValueResult{
false,
fmt.Sprintf("Value was none of %#v, actual value was %#v", names, v),
}
})
}
// IsStringContaining validates that the the actual value contains the specified substring.
func IsStringContaining(needle string) IsDef {
return Is("is string containing", func(v interface{}) ValueResult {
strV, ok := v.(string)
if !ok {
return ValueResult{
false,
fmt.Sprintf("Unable to convert '%v' to string", v),
}
}
if !strings.Contains(strV, needle) {
return ValueResult{
false,
fmt.Sprintf("String '%s' did not contain substring '%s'", strV, needle),
}
}
return ValidVR
})
}
// IsDuration tests that the given value is a duration.
var IsDuration = Is("is a duration", func(v interface{}) ValueResult {
if _, ok := v.(time.Duration); ok {
return ValidVR
}
return ValueResult{
false,
fmt.Sprintf("Expected a time.duration, got '%v' which is a %T", v, v),
}
})
// IsEqual tests that the given object is equal to the actual object.
func IsEqual(to interface{}) IsDef {
return Is("equals", func(v interface{}) ValueResult {
if assert.ObjectsAreEqual(v, to) {
return ValidVR
}
return ValueResult{
false,
fmt.Sprintf("objects not equal: actual(%v) != expected(%v)", v, to),
}
})
}
// IsEqualToValue tests that the given value is equal to the actual value.
func IsEqualToValue(to interface{}) IsDef {
return Is("equals", func(v interface{}) ValueResult {
if assert.ObjectsAreEqualValues(v, to) {
return ValidVR
}
return ValueResult{
false,
fmt.Sprintf("values not equal: actual(%v) != expected(%v)", v, to),
}
})
}
// IsNil tests that a value is nil.
var IsNil = Is("is nil", func(v interface{}) ValueResult {
if v == nil {
return ValidVR
}
return ValueResult{
false,
fmt.Sprintf("Value %v is not nil", v),
}
})
func intGtChecker(than int) ValueValidator {
return func(v interface{}) ValueResult {
n, ok := v.(int)
if !ok {
msg := fmt.Sprintf("%v is a %T, but was expecting an int!", v, v)
return ValueResult{false, msg}
}
if n > than {
return ValidVR
}
return ValueResult{
false,
fmt.Sprintf("%v is not greater than %v", n, than),
}
}
}
// IsIntGt tests that a value is an int greater than.
func IsIntGt(than int) IsDef {
return Is("greater than", intGtChecker(than))
} | libbeat/common/mapval/is_defs.go | 0.710226 | 0.468791 | is_defs.go | starcoder |
package main
import (
"bufio"
"fmt"
"math/rand"
"os"
"strconv"
"strings"
"time"
)
// Piece is encoded as an int.
type Piece int
// Board is a slice of Pieces.
type Board []Piece
// Standard board dimensions 7x6.
const (
boardWidth = 7
boardHeight = 6
numSimulations = 1000
)
// Map names to Piece encodings.
const (
EMPTY Piece = iota
P1
P2
)
// Helpful constants.
const MaxUint = ^uint(0)
const MinUint = 0
const MaxInt = int(MaxUint >> 1)
const MinInt = -MaxInt - 1
// BoardDef represents board defaults at init time (mostly for testing).
type BoardDef map[int]Piece
// ValidMove represents moves that can be made.
type ValidMove []bool
// initBoard sets up the initial board state.
// Cells that are not empty are supplied via defs with the key
// representing the 1d index and the value representing the piece encoding.
func initBoard(defs BoardDef) Board {
board := make(Board, boardWidth*boardHeight)
for idx := range board {
if defs[idx] != EMPTY {
board[idx] = defs[idx]
} else {
board[idx] = EMPTY
}
}
return board
}
// coordToIdx converts a cartesian coordinate to a 1d index.
func coordToIdx(x, y int) int {
return x + (y * boardWidth)
}
// idxToCoord converts a 1d index to a pair of cartesian coordinates.
func idxToCoord(idx int) (int, int) {
x := idx % boardWidth
y := idx / boardWidth
return x, y
}
// collectFour scans the board on the x, y, and x+y axis returning all
// valid combinations of adjacent cells as a slice of strings.
func collectFour(board Board) []string {
vals := []string{}
for idx := 0; idx < (boardWidth * boardHeight); idx++ {
x, y := idxToCoord(idx)
// Scan x-axis to the right.
if x+3 < boardWidth {
vals = append(vals, fmt.Sprintf("%v%v%v%v", board[idx], board[idx+1], board[idx+2], board[idx+3]))
}
// Scan y-axis down.
if y+3 < boardHeight {
vals = append(vals, fmt.Sprintf("%v%v%v%v", board[idx], board[coordToIdx(x, y+1)], board[coordToIdx(x, y+2)], board[coordToIdx(x, y+3)]))
}
// Scan diagonal down and right.
if x+3 < boardWidth && y+3 < boardHeight {
vals = append(vals, fmt.Sprintf("%v%v%v%v", board[idx], board[coordToIdx(x+1, y+1)], board[coordToIdx(x+2, y+2)], board[coordToIdx(x+3, y+3)]))
}
// Scan diagonal up and right.
if x+3 < boardWidth && y-3 >= 0 {
vals = append(vals, fmt.Sprintf("%v%v%v%v", board[idx], board[coordToIdx(x+1, y-1)], board[coordToIdx(x+2, y-2)], board[coordToIdx(x+3, y-3)]))
}
}
return vals
}
// gameOver specifies if the game is over and who won (P1 or P2).
// If Piece is EMPTY, the game is ongoing.
func gameOver(board Board) Piece {
groups := collectFour(board)
p1Str := strconv.Itoa(int(P1))
p2Str := strconv.Itoa(int(P2))
for _, group := range groups {
if group == strings.Repeat(p1Str, 4) {
return P1
}
if group == strings.Repeat(p2Str, 4) {
return P2
}
}
return EMPTY
}
// validMoves returns a slice of valid moves.
func validMoves(board Board) []bool {
valid := make([]bool, boardWidth)
for col := 0; col < boardWidth; col++ {
if board[col] == EMPTY {
valid[col] = true
}
}
return valid
}
// move places a piece on the board if the position is valid.
func move(board Board, move int, piece Piece) (Board, error) {
valid := validMoves(board)
if !valid[move] {
return board, fmt.Errorf("move: invalid move specified")
}
for row := boardHeight - 1; row >= 0; row-- {
idx := coordToIdx(move, row)
if board[idx] == EMPTY {
board[idx] = piece
return board, nil
}
}
// Should be unreachable.
return board, fmt.Errorf("move: invalid code path")
}
// nextTurn specifies who goes next.
func nextTurn(currPlayer Piece) Piece {
if currPlayer == P1 {
return P2
}
return P1
}
// printBoard prints the board.
func printBoard(board Board) {
bData := [][]string{
{"1", "2", "3", "4", "5", "6", "7"},
}
for row := 0; row < boardHeight; row++ {
rData := []string{}
for col := 0; col < boardWidth; col++ {
idx := coordToIdx(col, row)
if board[idx] == EMPTY {
rData = append(rData, "_")
} else if board[idx] == P1 {
rData = append(rData, "X")
} else if board[idx] == P2 {
rData = append(rData, "O")
}
}
bData = append(bData, rData)
}
for _, row := range bData {
fmt.Println(strings.Join(row, " "))
}
}
// validInput returns a bool indicating whether the input is valid.
func validInput(input string) bool {
valid := []string{"1", "2", "3", "4", "5", "6", "7", "8", "9"}
for _, entry := range valid {
if input == entry {
return true
}
}
return false
}
func promptInput(player Piece) {
playerStr := ""
if player == P1 {
playerStr = "P1"
} else {
playerStr = "P2"
}
fmt.Printf("[%v] Enter a move (1-7): ", playerStr)
}
// readInput takes input from stdin, validates it, and returns a Move.
func readInput() int {
reader := bufio.NewReader(os.Stdin)
input, err := reader.ReadString('\n')
if err != nil {
fmt.Println(err)
return -1
}
input = strings.TrimSpace(input)
if validInput(input) {
move, err := strconv.Atoi(input)
// Should not be possible post-validation.
if err != nil {
fmt.Println(err)
return -1
}
// Subtract one to convert to idx value.
return move - 1
}
return -1
}
func endGame(board Board, piece Piece) {
if piece == P1 {
fmt.Println("Game over! P1 wins.")
} else {
fmt.Println("Game over! P2 wins.")
}
printBoard(board)
os.Exit(0)
}
func filterValid(moves []bool) []int {
ret := []int{}
for i, v := range moves {
if v {
ret = append(ret, i)
}
}
return ret
}
func getBestNextMove(board Board, currPlayer Piece) int {
results := make(map[int]int)
bestMove := -1
highScore := MinInt
for i := 0; i < numSimulations; i++ {
player := currPlayer
boardCopy := make(Board, len(board))
copy(boardCopy, board)
score := boardWidth * boardHeight
nextMoves := filterValid(validMoves(boardCopy))
firstMove := -1
moveCnt := 1
for len(nextMoves) > 0 {
moveCnt++
randMove := nextMoves[rand.Intn(len(nextMoves))]
boardCopy, err := move(boardCopy, randMove, player)
if err != nil {
fmt.Println("Error making move:")
fmt.Println(err)
}
// This move starts the tree.
if firstMove == -1 {
firstMove = randMove
}
if piece := gameOver(boardCopy); piece != EMPTY {
// P1 is the human, so a win deducts points
if piece == P1 {
score *= -1
}
break
}
score -= 1
player = nextTurn(player)
nextMoves = filterValid(validMoves(boardCopy))
}
if firstMove >= 0 {
results[firstMove] += score
}
}
for move, score := range results {
if score > highScore {
bestMove = move
highScore = score
}
}
return bestMove
}
func main() {
rand.Seed(time.Now().UnixNano())
defs := BoardDef{}
board := initBoard(defs)
activePlayer := P1
var moveInput int
for {
if piece := gameOver(board); piece != EMPTY {
endGame(board, piece)
}
printBoard(board)
if activePlayer == P1 {
promptInput(activePlayer)
moveInput = readInput()
} else {
moveInput = getBestNextMove(board, P2)
fmt.Printf("CPU chooses %v\n", int(moveInput)+1)
}
if moveInput >= 0 {
newBoard, err := move(board, moveInput, activePlayer)
if err != nil {
fmt.Println("Error making move:")
fmt.Println(err)
} else {
activePlayer = nextTurn(activePlayer)
board = newBoard
}
} else {
fmt.Println("Invalid move.")
}
}
} | main.go | 0.731922 | 0.546194 | main.go | starcoder |
package gocudnn
/*
#include <cudnn.h>
*/
import "C"
import (
"unsafe"
"github.com/dereklstinson/cutil"
)
//FindRNNForwardInferenceAlgorithmEx finds the inference algorithmEx
func (r *RNND) FindRNNForwardInferenceAlgorithmEx(
handle *Handle,
xD []*TensorD, //Input. An array of fully packed tensor descriptors describing the input to each recurrent iteration (one descriptor per iteration).
x cutil.Mem, //input
hxD *TensorD, //Input. A fully packed tensor descriptor describing the initial hidden state of the RNN.
hx cutil.Mem, //input
cxD *TensorD, //Input. A fully packed tensor descriptor describing the initial cell state for LSTM networks.
cx cutil.Mem, //input
wD *FilterD, //Input. Handle to a previously initialized filter descriptor describing the weights for the RNN.
w cutil.Mem, //Input
yD []*TensorD, //input An array of fully packed tensor descriptors.
y cutil.Mem, //Output Data pointer to GPU memory associated with the output tensor descriptor yDesc
hyD *TensorD, //input A fully packed tensor descriptor describing the final hidden state of the RNN.
hy cutil.Mem, //Output. Data pointer to GPU memory associated with the tensor descriptor hyDesc. If
cyD *TensorD, //Input. A fully packed tensor descriptor describing the final cell state for LSTM networks.
cy cutil.Mem, //output
findIntensity float32,
wspace cutil.Mem, wspacesize uint,
) ([]AlgorithmPerformance, error) {
algocount, err := r.getRNNForwardInferenceAlgorithmMaxCount(handle)
if err != nil {
return nil, err
}
seqLength := (C.int)(len(xD))
tocxD := tensorDArrayToC(xD)
tocyD := tensorDArrayToC(yD)
var retactAlgoCount C.int
perfResults := make([]C.cudnnAlgorithmPerformance_t, algocount)
if handle.w != nil {
err = handle.w.Work(func() error {
return Status(C.cudnnFindRNNForwardInferenceAlgorithmEx(
handle.x,
r.descriptor,
seqLength,
&tocxD[0], x.Ptr(),
hxD.descriptor, hx.Ptr(),
cxD.descriptor, cx.Ptr(),
wD.descriptor, w.Ptr(),
&tocyD[0], y.Ptr(),
hyD.descriptor, hy.Ptr(),
cyD.descriptor, cy.Ptr(),
C.float(findIntensity),
(C.int)(algocount),
&retactAlgoCount,
&perfResults[0],
wspace.Ptr(), C.size_t(wspacesize),
)).error("(r *RNND) FindRNNForwardInferenceAlgorithmEx")
})
} else {
err = Status(C.cudnnFindRNNForwardInferenceAlgorithmEx(
handle.x,
r.descriptor,
seqLength,
&tocxD[0], x.Ptr(),
hxD.descriptor, hx.Ptr(),
cxD.descriptor, cx.Ptr(),
wD.descriptor, w.Ptr(),
&tocyD[0], y.Ptr(),
hyD.descriptor, hy.Ptr(),
cyD.descriptor, cy.Ptr(),
C.float(findIntensity),
(C.int)(algocount),
&retactAlgoCount,
&perfResults[0],
wspace.Ptr(), C.size_t(wspacesize),
)).error("(r *RNND) FindRNNForwardInferenceAlgorithmEx")
}
return calgoperftogoarray(perfResults, setfinalizer), err
}
//FindRNNForwardInferenceAlgorithmExUS is like FindRNNForwardInferenceAlgorithmEx but uses unsafe.Pointer instead of cutil.Mem
func (r *RNND) FindRNNForwardInferenceAlgorithmExUS(
handle *Handle,
xD []*TensorD, //Input. An array of fully packed tensor descriptors describing the input to each recurrent iteration (one descriptor per iteration).
x unsafe.Pointer, //input
hxD *TensorD, //Input. A fully packed tensor descriptor describing the initial hidden state of the RNN.
hx unsafe.Pointer, //input
cxD *TensorD, //Input. A fully packed tensor descriptor describing the initial cell state for LSTM networks.
cx unsafe.Pointer, //input
wD *FilterD, //Input. Handle to a previously initialized filter descriptor describing the weights for the RNN.
w unsafe.Pointer, //Input
yD []*TensorD, //input An array of fully packed tensor descriptors.
y unsafe.Pointer, //Output Data pointer to GPU memory associated with the output tensor descriptor yDesc
hyD *TensorD, //input A fully packed tensor descriptor describing the final hidden state of the RNN.
hy unsafe.Pointer, //Output. Data pointer to GPU memory associated with the tensor descriptor hyDesc. If
cyD *TensorD, //Input. A fully packed tensor descriptor describing the final cell state for LSTM networks.
cy unsafe.Pointer, //output
findIntensity float32,
wspace unsafe.Pointer, wspacesize uint,
) ([]AlgorithmPerformance, error) {
reqcount, err := r.getRNNForwardInferenceAlgorithmMaxCount(handle)
if err != nil {
return nil, err
}
seqLength := (C.int)(len(xD))
tocxD := tensorDArrayToC(xD)
tocyD := tensorDArrayToC(yD)
var retactAlgoCount C.int
perfResults := make([]C.cudnnAlgorithmPerformance_t, reqcount)
if handle.w != nil {
err = handle.w.Work(func() error {
return Status(C.cudnnFindRNNForwardInferenceAlgorithmEx(
handle.x,
r.descriptor,
seqLength,
&tocxD[0], x,
hxD.descriptor, hx,
cxD.descriptor, cx,
wD.descriptor, w,
&tocyD[0], y,
hyD.descriptor, hy,
cyD.descriptor, cy,
C.float(findIntensity),
(C.int)(reqcount),
&retactAlgoCount,
&perfResults[0],
wspace, C.size_t(wspacesize),
)).error(" (r *RNND) FindRNNForwardInferenceAlgorithmExUS")
})
} else {
err = Status(C.cudnnFindRNNForwardInferenceAlgorithmEx(
handle.x,
r.descriptor,
seqLength,
&tocxD[0], x,
hxD.descriptor, hx,
cxD.descriptor, cx,
wD.descriptor, w,
&tocyD[0], y,
hyD.descriptor, hy,
cyD.descriptor, cy,
C.float(findIntensity),
(C.int)(reqcount),
&retactAlgoCount,
&perfResults[0],
wspace, C.size_t(wspacesize),
)).error(" (r *RNND) FindRNNForwardInferenceAlgorithmExUS")
}
return calgoperftogoarray(perfResults, setfinalizer), err
}
//GetRNNForwardTrainingAlgorithmMaxCount gets the max number of algorithms for rnnforward training algo
func (r *RNND) getRNNForwardTrainingAlgorithmMaxCount(handle *Handle) (int32, error) {
var count C.int
var err error
if handle.w != nil {
err = handle.w.Work(func() error {
return Status(C.cudnnGetRNNForwardTrainingAlgorithmMaxCount(
handle.x,
r.descriptor,
&count)).error("(r *RNND) GetRNNForwardTrainingAlgorithmMaxCount")
})
} else {
err = Status(C.cudnnGetRNNForwardTrainingAlgorithmMaxCount(
handle.x,
r.descriptor,
&count)).error("(r *RNND) GetRNNForwardTrainingAlgorithmMaxCount")
}
return int32(count), err
}
//FindRNNForwardTrainingAlgorithmEx finds and orders the performance of rnn Algorithm for training returns that list with an error
func (r *RNND) FindRNNForwardTrainingAlgorithmEx(
handle *Handle,
xD []*TensorD, //input
x cutil.Mem, //input
hxD *TensorD, //input: A fully packed tensor descriptor describing the initial hidden state of the RNN.
hx cutil.Mem, //input
cxD *TensorD, // :input A fully packed tensor descriptor describing the initial cell state for LSTM networks.
cx cutil.Mem, //input
wD *FilterD, //input
w cutil.Mem, //input
yD []*TensorD, //Input. An array of fully packed tensor descriptors describing the output from each recurrent iteration (one descriptor per iteration).
y cutil.Mem, //output
hyD *TensorD, //input
hy cutil.Mem, //output
cyD *TensorD,
cy cutil.Mem, //output
findIntensity float32, //input
reqAlgocount int32, //input
wspace cutil.Mem, ///input
wspacesize uint,
rspace cutil.Mem, //input/output
rspacesize uint,
) ([]AlgorithmPerformance, error) {
reqcount, err := r.getRNNForwardTrainingAlgorithmMaxCount(handle)
if err != nil {
return nil, err
}
seqLength := (C.int)(len(xD))
tocxD := tensorDArrayToC(xD)
tocyD := tensorDArrayToC(yD)
var actualcount C.int
perfresults := make([]C.cudnnAlgorithmPerformance_t, reqAlgocount)
if handle.w != nil {
err = handle.w.Work(func() error {
if wspace == nil {
return Status(C.cudnnFindRNNForwardTrainingAlgorithmEx(
handle.x,
r.descriptor,
seqLength,
&tocxD[0],
x.Ptr(),
hxD.descriptor,
hx.Ptr(),
cxD.descriptor,
cx.Ptr(),
wD.descriptor,
w.Ptr(),
&tocyD[0],
y.Ptr(),
hyD.descriptor,
hy.Ptr(),
cyD.descriptor,
cy.Ptr(),
C.float(findIntensity),
C.int(reqcount),
&actualcount,
&perfresults[0],
nil,
C.size_t(0),
rspace.Ptr(),
C.size_t(rspacesize),
)).error("(r *RNND) FindRNNForwardTrainingAlgorithmEx")
}
return Status(C.cudnnFindRNNForwardTrainingAlgorithmEx(
handle.x,
r.descriptor,
seqLength,
&tocxD[0], x.Ptr(),
hxD.descriptor, hx.Ptr(),
cxD.descriptor, cx.Ptr(),
wD.descriptor, w.Ptr(),
&tocyD[0], y.Ptr(),
hyD.descriptor, hy.Ptr(),
cyD.descriptor, cy.Ptr(),
C.float(findIntensity),
C.int(reqcount),
&actualcount, &perfresults[0],
wspace.Ptr(), C.size_t(wspacesize),
rspace.Ptr(), C.size_t(rspacesize),
)).error("(r *RNND) FindRNNForwardTrainingAlgorithmEx")
})
} else {
if wspace == nil {
err = Status(C.cudnnFindRNNForwardTrainingAlgorithmEx(
handle.x,
r.descriptor,
seqLength,
&tocxD[0],
x.Ptr(),
hxD.descriptor,
hx.Ptr(),
cxD.descriptor,
cx.Ptr(),
wD.descriptor,
w.Ptr(),
&tocyD[0],
y.Ptr(),
hyD.descriptor,
hy.Ptr(),
cyD.descriptor,
cy.Ptr(),
C.float(findIntensity),
C.int(reqcount),
&actualcount,
&perfresults[0],
nil,
C.size_t(0),
rspace.Ptr(),
C.size_t(rspacesize),
)).error("(r *RNND) FindRNNForwardTrainingAlgorithmEx")
} else {
err = Status(C.cudnnFindRNNForwardTrainingAlgorithmEx(
handle.x,
r.descriptor,
seqLength,
&tocxD[0], x.Ptr(),
hxD.descriptor, hx.Ptr(),
cxD.descriptor, cx.Ptr(),
wD.descriptor, w.Ptr(),
&tocyD[0], y.Ptr(),
hyD.descriptor, hy.Ptr(),
cyD.descriptor, cy.Ptr(),
C.float(findIntensity),
C.int(reqcount),
&actualcount, &perfresults[0],
wspace.Ptr(), C.size_t(wspacesize),
rspace.Ptr(), C.size_t(rspacesize),
)).error("(r *RNND) FindRNNForwardTrainingAlgorithmEx")
}
}
if err != nil {
return nil, err
}
return calgoperftogoarray(perfresults, handle.gogc), err
}
//FindRNNForwardTrainingAlgorithmExUS is like FindRNNForwardTrainingAlgorithmEx but uses unsafe.Pointer instead of cutil.Mem
func (r *RNND) FindRNNForwardTrainingAlgorithmExUS(
handle *Handle,
xD []*TensorD, x unsafe.Pointer,
hxD *TensorD, hx unsafe.Pointer,
cxD *TensorD, cx unsafe.Pointer,
wD *FilterD, w unsafe.Pointer,
yD []*TensorD, y unsafe.Pointer,
hyD *TensorD, hy unsafe.Pointer,
cyD *TensorD, cy unsafe.Pointer,
findIntensity float32, //input
wspace unsafe.Pointer, wspacesize uint,
rspace unsafe.Pointer, rspacesize uint,
) ([]AlgorithmPerformance, error) {
reqcount, err := r.getRNNForwardTrainingAlgorithmMaxCount(handle)
if err != nil {
return nil, err
}
seqLength := (C.int)(len(xD))
tocxD := tensorDArrayToC(xD)
tocyD := tensorDArrayToC(yD)
var actualcount C.int
perfresults := make([]C.cudnnAlgorithmPerformance_t, reqcount)
if handle.w != nil {
err = handle.w.Work(func() error {
return Status(C.cudnnFindRNNForwardTrainingAlgorithmEx(
handle.x,
r.descriptor,
seqLength,
&tocxD[0], x,
hxD.descriptor, hx,
cxD.descriptor, cx,
wD.descriptor, w,
&tocyD[0], y,
hyD.descriptor, hy,
cyD.descriptor, cy,
C.float(findIntensity),
C.int(reqcount),
&actualcount,
&perfresults[0],
wspace, C.size_t(0),
rspace, C.size_t(rspacesize),
)).error("(r *RNND) FindRNNForwardTrainingAlgorithmExUS")
})
} else {
err = Status(C.cudnnFindRNNForwardTrainingAlgorithmEx(
handle.x,
r.descriptor,
seqLength,
&tocxD[0], x,
hxD.descriptor, hx,
cxD.descriptor, cx,
wD.descriptor, w,
&tocyD[0], y,
hyD.descriptor, hy,
cyD.descriptor, cy,
C.float(findIntensity),
C.int(reqcount),
&actualcount,
&perfresults[0],
wspace, C.size_t(0),
rspace, C.size_t(rspacesize),
)).error("(r *RNND) FindRNNForwardTrainingAlgorithmExUS")
}
return calgoperftogoarray(perfresults, handle.gogc), err
}
//GetRNNForwardInferenceAlgorithmMaxCount returns the maxcount and error
func (r *RNND) getRNNForwardInferenceAlgorithmMaxCount(
handle *Handle,
) (int32, error) {
var count C.int
var err error
if handle.w != nil {
err = handle.w.Work(func() error {
return Status(C.cudnnGetRNNForwardInferenceAlgorithmMaxCount(
handle.x,
r.descriptor,
&count,
)).error("GetRNNForwardInferenceAlgorithmMaxCount")
})
} else {
err = Status(C.cudnnGetRNNForwardInferenceAlgorithmMaxCount(
handle.x,
r.descriptor,
&count,
)).error("GetRNNForwardInferenceAlgorithmMaxCount")
}
return int32(count), err
} | cudnnRNN_algofindfw.go | 0.623262 | 0.438364 | cudnnRNN_algofindfw.go | starcoder |
package dinerogo
import (
"errors"
"fmt"
"math"
)
// GetAmount : Get the amount of the dinero object
func (d *dinero) GetAmount() int64 {
return d.amount
}
// GetCurrency : Get currency of the Dinero Obj
func (d *dinero) GetCurrency() string {
return d.currency
}
// GetPrecision : Get the decimal precision of the Dinero obj
func (d *dinero) GetPrecision() uint8 {
return d.precision
}
//ConvertPrecision : Convert the decimal precision and the amount with a new precision
func (d *dinero) ConvertPrecision(newPrecision uint8) *dinero {
if d.GetPrecision() == newPrecision {
return d
}
if d.GetPrecision() != 0 {
return &dinero{
amount: int64(math.RoundToEven((float64(d.GetAmount()) / (math.Pow(10, float64(d.GetPrecision())))) * (math.Pow(10, float64(newPrecision))))),
currency: d.GetCurrency(),
precision: newPrecision,
}
}
return &dinero{
amount: int64(math.RoundToEven(float64(d.GetAmount()) * (math.Pow(10, float64(newPrecision))))),
currency: d.GetCurrency(),
precision: newPrecision,
}
}
// Add : Add a Dinero object to another Dinero object
func (d *dinero) Add(dinerotoAdd *dinero) (*dinero, error) {
if d.GetCurrency() != dinerotoAdd.GetCurrency() {
return &dinero{}, errors.New("dinero obj must be same currency")
}
if d.GetPrecision() == dinerotoAdd.GetPrecision() {
return &dinero{
amount: d.GetAmount() + dinerotoAdd.GetAmount(),
currency: d.GetCurrency(),
precision: d.GetPrecision(),
}, nil
}
if dinerotoAdd.GetPrecision() > d.GetPrecision() {
newDinero := d.ConvertPrecision(dinerotoAdd.GetPrecision())
return &dinero{
amount: dinerotoAdd.GetAmount() + newDinero.GetAmount(),
currency: d.GetCurrency(),
precision: dinerotoAdd.GetPrecision(),
}, nil
}
newDinero := dinerotoAdd.ConvertPrecision(d.GetPrecision())
return &dinero{
amount: d.GetAmount() + newDinero.GetAmount(),
currency: d.GetCurrency(),
precision: d.GetPrecision(),
}, nil
}
// Subtract : Subtract a Dinero object to another Dinero object
func (d *dinero) Subtract(dineroToSubtract *dinero) (*dinero, error) {
if d.GetAmount() < dineroToSubtract.GetAmount() {
return &dinero{}, errors.New("the dinero of subtract can be more than the actual")
}
if d.GetCurrency() != dineroToSubtract.GetCurrency() {
return &dinero{}, errors.New("dinero obj must be same currency")
}
if d.GetPrecision() == dineroToSubtract.GetPrecision() {
return &dinero{
amount: d.GetAmount() - dineroToSubtract.GetAmount(),
currency: d.GetCurrency(),
precision: d.GetPrecision(),
}, nil
}
if dineroToSubtract.GetPrecision() > d.GetPrecision() {
newDinero := d.ConvertPrecision(dineroToSubtract.GetPrecision())
return &dinero{
amount: dineroToSubtract.GetAmount() - newDinero.GetAmount(),
currency: d.GetCurrency(),
precision: dineroToSubtract.GetPrecision(),
}, nil
}
newDinero := dineroToSubtract.ConvertPrecision(d.GetPrecision())
return &dinero{
amount: d.GetAmount() - newDinero.GetAmount(),
currency: d.GetCurrency(),
precision: d.GetPrecision(),
}, nil
}
// Multiply : Multiply the value of a Dinero amount
func (d *dinero) Multiply(multiplier int64) *dinero {
return &dinero{
amount: int64(math.RoundToEven(float64(d.GetAmount()) * float64(multiplier))),
currency: d.GetCurrency(),
precision: d.GetPrecision(),
}
}
// Divide : Divide the value of a Dinero amount
func (d *dinero) Divide(divider int64) (*dinero, error) {
if divider == 0 {
return &dinero{}, errors.New("the divider can't be 0")
}
return &dinero{
amount: int64(math.RoundToEven(float64(d.GetAmount()) / float64(divider))),
currency: d.GetCurrency(),
precision: d.GetPrecision(),
}, nil
}
// Percentage : Get a Percentage of the amount of money
func (d *dinero) Percentage(percentage uint8) (*dinero, error) {
if percentage <= 0 && percentage > 100 {
return &dinero{}, errors.New("the percentage must be from 1 to 100")
}
return &dinero{
amount: int64(float64(d.GetAmount()) * float64(percentage) / 100),
currency: d.GetCurrency(),
precision: d.GetPrecision(),
}, nil
}
// EqualsTo : Compare is the Dinero object is representing the same Dinero value
func (d *dinero) EqualsTo(dineroToCompare *dinero) (bool, error) {
if d.GetCurrency() != dineroToCompare.GetCurrency() {
return false, fmt.Errorf("the can't compare %s with %s", d.GetCurrency(), dineroToCompare.GetCurrency())
}
if d.GetPrecision() != dineroToCompare.GetPrecision() {
newDinero := dineroToCompare.ConvertPrecision(d.GetPrecision())
return d.GetAmount() == newDinero.GetAmount(), nil
}
return d.GetAmount() == dineroToCompare.GetAmount(), nil
}
// LessThan : Compare if a dinero object is less than other
func (d *dinero) LessThan(dineroToCompare *dinero) (bool, error) {
if d.GetCurrency() != dineroToCompare.GetCurrency() {
return false, fmt.Errorf("the can't compare %s with %s", d.GetCurrency(), dineroToCompare.GetCurrency())
}
if d.GetPrecision() != dineroToCompare.GetPrecision() {
newDinero := dineroToCompare.ConvertPrecision(d.GetPrecision())
return d.GetAmount() < newDinero.GetAmount(), nil
}
return d.GetAmount() < dineroToCompare.GetAmount(), nil
}
// LessThanOrEquals : Compare if a dinero object is less than or Equals to other
func (d *dinero) LessThanOrEquals(dineroToCompare *dinero) (bool, error) {
if d.GetCurrency() != dineroToCompare.GetCurrency() {
return false, fmt.Errorf("the can't compare %s with %s", d.GetCurrency(), dineroToCompare.GetCurrency())
}
if d.GetPrecision() != dineroToCompare.GetPrecision() {
newDinero := dineroToCompare.ConvertPrecision(d.GetPrecision())
return d.GetAmount() <= newDinero.GetAmount(), nil
}
return d.GetAmount() <= dineroToCompare.GetAmount(), nil
}
// GreatherThan : Compare if a dinero object is greather than to other
func (d *dinero) GreatherThan(dineroToCompare *dinero) (bool, error) {
if d.GetCurrency() != dineroToCompare.GetCurrency() {
return false, fmt.Errorf("the can't compare %s with %s", d.GetCurrency(), dineroToCompare.GetCurrency())
}
if d.GetPrecision() != dineroToCompare.GetPrecision() {
newDinero := dineroToCompare.ConvertPrecision(d.GetPrecision())
return d.GetAmount() > newDinero.GetAmount(), nil
}
return d.GetAmount() > dineroToCompare.GetAmount(), nil
}
// GreatherThanOrEquals : Compare if a dinero object is greather than or Equals to other
func (d *dinero) GreatherThanOrEquals(dineroToCompare *dinero) (bool, error) {
if d.GetCurrency() != dineroToCompare.GetCurrency() {
return false, fmt.Errorf("the can't compare %s with %s", d.GetCurrency(), dineroToCompare.GetCurrency())
}
if d.GetPrecision() != dineroToCompare.GetPrecision() {
newDinero := dineroToCompare.ConvertPrecision(d.GetPrecision())
return d.GetAmount() >= newDinero.GetAmount(), nil
}
return d.GetAmount() >= dineroToCompare.GetAmount(), nil
}
// HasSameCurrency : Compare the currency inside of the Dinero object
func (d *dinero) HasSameCurrency(dineroToCompare *dinero) bool {
return d.GetCurrency() == dineroToCompare.GetCurrency()
}
// HasSameAmount : Compare the amount inside of two Dinero object, converting to a same precision
func (d *dinero) HasSameAmount(dineroToCompare *dinero) bool {
if d.GetPrecision() == dineroToCompare.GetPrecision() {
return d.GetAmount() == dineroToCompare.GetAmount()
}
newDinero := dineroToCompare.ConvertPrecision(d.GetPrecision())
return d.GetAmount() == newDinero.GetAmount()
}
// IsZero : Valid if the amount inside of Dinero obj it's 0
func (d *dinero) IsZero() bool {
return d.GetAmount() == 0
}
// IsPositive : Valid if the amount inside of the Dinero obj it's more than 0
func (d *dinero) IsPositive() bool {
return d.GetAmount() > 0
}
// IsNegative : Valid if the amount inside of the Dinero obj it's less than 0
func (d *dinero) IsNegative() bool {
return d.GetAmount() < 0
}
// Minium : Use it for get the minimun value in a Array of Dineros
func (d *dinero) Minimun(dineros []dinero) *dinero {
var minAmount int64
var index int64
for i, dinero := range dineros {
convertedDinero := dinero.ConvertPrecision(2)
if i == 0 {
minAmount = convertedDinero.GetAmount()
} else {
if minAmount > convertedDinero.GetAmount() {
minAmount = convertedDinero.GetAmount()
index = int64(i)
}
}
}
result := dineros[index]
return &result
}
//Maximun : Use it for get the maximun value in a Array of Dineros
func (d *dinero) Maximun(dineros []dinero) *dinero {
var maxAmount int64
var index int64
for i, dinero := range dineros {
convertedDinero := dinero.ConvertPrecision(2)
if i == 0 {
maxAmount = convertedDinero.GetAmount()
} else {
if maxAmount < convertedDinero.GetAmount() {
maxAmount = convertedDinero.GetAmount()
index = int64(i)
}
}
}
result := dineros[index]
return &result
} | methods.go | 0.747616 | 0.474083 | methods.go | starcoder |
package processor
import (
"encoding/json"
"strconv"
"time"
"github.com/Jeffail/benthos/v3/lib/condition"
"github.com/Jeffail/benthos/v3/lib/log"
"github.com/Jeffail/benthos/v3/lib/message/tracing"
"github.com/Jeffail/benthos/v3/lib/metrics"
"github.com/Jeffail/benthos/v3/lib/types"
olog "github.com/opentracing/opentracing-go/log"
)
//------------------------------------------------------------------------------
func init() {
Constructors[TypeSwitch] = TypeSpec{
constructor: NewSwitch,
Summary: `
A processor that lists child case objects each containing a condition and
processors. Each batch of messages is tested against the condition of each child
case until a condition passes, whereby the processors of that case will be
executed on the batch.`,
Description: `
Each case may specify a boolean ` + "`fallthrough`" + ` field indicating whether
the next case should be executed after it (the default is ` + "`false`" + `.)
A case takes this form:
` + "``` yaml" + `
- condition:
type: foo
processors:
- type: foo
fallthrough: false
` + "```" + `
In order to switch each message of a batch individually use this processor with
the ` + "[`for_each`](/docs/components/processors/for_each)" + ` processor.
You can find a [full list of conditions here](/docs/components/conditions/about).`,
Footnotes: `
## Examples
George is very noisy and lies quite often. For any messages received over the
Kafka topic "from_george", which are messages from George, we want to lowercase
everything he says and prefix it with "PROBABLY FALSE: ". For all other messages
we want to uppercase them just to further spite him.
` + "```yaml" + `
pipeline:
processors:
- switch:
- condition:
bloblang: meta("kafka_topic") == "from_george"
processors:
- bloblang: root = "PROBABLY FALSE: %v".format(content().lowercase())
- processors:
- bloblang: root = content().uppercase()
` + "```" + `
You're cool George but you're also a piece of work.`,
sanitiseConfigFunc: func(conf Config) (interface{}, error) {
switchSlice := []interface{}{}
for _, switchCase := range conf.Switch {
var sanProcs []interface{}
for _, proc := range switchCase.Processors {
sanProc, err := SanitiseConfig(proc)
if err != nil {
return nil, err
}
sanProcs = append(sanProcs, sanProc)
}
sanCond, err := condition.SanitiseConfig(switchCase.Condition)
if err != nil {
return nil, err
}
sanit := map[string]interface{}{
"condition": sanCond,
"processors": sanProcs,
"fallthrough": switchCase.Fallthrough,
}
switchSlice = append(switchSlice, sanit)
}
return switchSlice, nil
},
}
}
//------------------------------------------------------------------------------
// SwitchCaseConfig contains a condition, processors and other fields for an
// individual case in the Switch processor.
type SwitchCaseConfig struct {
Condition condition.Config `json:"condition" yaml:"condition"`
Processors []Config `json:"processors" yaml:"processors"`
Fallthrough bool `json:"fallthrough" yaml:"fallthrough"`
}
// NewSwitchCaseConfig returns a new SwitchCaseConfig with default values.
func NewSwitchCaseConfig() SwitchCaseConfig {
cond := condition.NewConfig()
cond.Type = condition.TypeStatic
cond.Static = true
return SwitchCaseConfig{
Condition: cond,
Processors: []Config{},
Fallthrough: false,
}
}
// UnmarshalJSON ensures that when parsing configs that are in a map or slice
// the default values are still applied.
func (s *SwitchCaseConfig) UnmarshalJSON(bytes []byte) error {
type confAlias SwitchCaseConfig
aliased := confAlias(NewSwitchCaseConfig())
if err := json.Unmarshal(bytes, &aliased); err != nil {
return err
}
*s = SwitchCaseConfig(aliased)
return nil
}
// UnmarshalYAML ensures that when parsing configs that are in a map or slice
// the default values are still applied.
func (s *SwitchCaseConfig) UnmarshalYAML(unmarshal func(interface{}) error) error {
type confAlias SwitchCaseConfig
aliased := confAlias(NewSwitchCaseConfig())
if err := unmarshal(&aliased); err != nil {
return err
}
*s = SwitchCaseConfig(aliased)
return nil
}
//------------------------------------------------------------------------------
// SwitchConfig is a config struct containing fields for the Switch processor.
type SwitchConfig []SwitchCaseConfig
// NewSwitchConfig returns a default SwitchConfig.
func NewSwitchConfig() SwitchConfig {
return SwitchConfig{}
}
//------------------------------------------------------------------------------
// switchCase contains a condition, processors and other fields for an
// individual case in the Switch processor.
type switchCase struct {
condition types.Condition
processors []types.Processor
fallThrough bool
}
// Switch is a processor that only applies child processors under a certain
// condition.
type Switch struct {
cases []switchCase
log log.Modular
mCount metrics.StatCounter
mSent metrics.StatCounter
mBatchSent metrics.StatCounter
}
// NewSwitch returns a Switch processor.
func NewSwitch(
conf Config, mgr types.Manager, log log.Modular, stats metrics.Type,
) (Type, error) {
var cases []switchCase
for i, caseConf := range conf.Switch {
prefix := strconv.Itoa(i)
var err error
var cond types.Condition
var procs []types.Processor
if cond, err = condition.New(
caseConf.Condition, mgr,
log.NewModule("."+prefix+".condition"),
metrics.Namespaced(stats, prefix+".condition"),
); err != nil {
return nil, err
}
for j, procConf := range caseConf.Processors {
procPrefix := prefix + "." + strconv.Itoa(j)
var proc types.Processor
if proc, err = New(
procConf, mgr,
log.NewModule("."+procPrefix),
metrics.Namespaced(stats, procPrefix),
); err != nil {
return nil, err
}
procs = append(procs, proc)
}
cases = append(cases, switchCase{
condition: cond,
processors: procs,
fallThrough: caseConf.Fallthrough,
})
}
return &Switch{
cases: cases,
log: log,
mCount: stats.GetCounter("count"),
mSent: stats.GetCounter("sent"),
mBatchSent: stats.GetCounter("batch.sent"),
}, nil
}
//------------------------------------------------------------------------------
// ProcessMessage applies the processor to a message, either creating >0
// resulting messages or a response to be sent back to the message source.
func (s *Switch) ProcessMessage(msg types.Message) (msgs []types.Message, res types.Response) {
s.mCount.Incr(1)
var procs []types.Processor
fellthrough := false
spans := tracing.CreateChildSpans(TypeSwitch, msg)
for i, switchCase := range s.cases {
if !fellthrough && !switchCase.condition.Check(msg) {
continue
}
procs = append(procs, switchCase.processors...)
for _, s := range spans {
s.LogFields(
olog.String("event", "case_match"),
olog.String("value", strconv.Itoa(i)),
)
}
if fellthrough = switchCase.fallThrough; !fellthrough {
break
}
}
for _, s := range spans {
s.Finish()
}
msgs, res = ExecuteAll(procs, msg)
s.mBatchSent.Incr(int64(len(msgs)))
totalParts := 0
for _, msg := range msgs {
totalParts += msg.Len()
}
s.mSent.Incr(int64(totalParts))
return
}
// CloseAsync shuts down the processor and stops processing requests.
func (s *Switch) CloseAsync() {
for _, s := range s.cases {
for _, proc := range s.processors {
proc.CloseAsync()
}
}
}
// WaitForClose blocks until the processor has closed down.
func (s *Switch) WaitForClose(timeout time.Duration) error {
stopBy := time.Now().Add(timeout)
for _, s := range s.cases {
for _, proc := range s.processors {
if err := proc.WaitForClose(time.Until(stopBy)); err != nil {
return err
}
}
}
return nil
}
//------------------------------------------------------------------------------ | lib/processor/switch.go | 0.731346 | 0.591841 | switch.go | starcoder |
package line
import (
"bufio"
"io"
"strings"
"github.com/influxdata/flux"
"github.com/influxdata/flux/execute"
"github.com/influxdata/flux/memory"
"github.com/influxdata/flux/values"
)
// ResultDecoder decodes raw input strings from a reader into a flux.Result.
// It uses a separator to split the input into tokens and generate table rows.
// Tokens are kept as they are and put into a table with schema `_time`, `_value`.
// The `_value` column contains tokens.
// The `_time` column contains the timestamps for when each `_value` has been read.
// Strings in `_value` are obtained from the io.Reader passed to the Decode function.
// ResultDecoder outputs one table once the reader reaches EOF.
type ResultDecoder struct {
reader *bufio.Reader
stats flux.Statistics
config *ResultDecoderConfig
}
// NewResultDecoder creates a new result decoder from config.
func NewResultDecoder(config *ResultDecoderConfig) *ResultDecoder {
return &ResultDecoder{config: config}
}
// TimeProvider gives the current time.
type TimeProvider interface {
CurrentTime() values.Time
}
// ResultDecoderConfig is the configuration for a result decoder.
type ResultDecoderConfig struct {
Separator byte
TimeProvider TimeProvider
}
func (rd *ResultDecoder) Do(f func(flux.Table) error) error {
timeCol := flux.ColMeta{Label: "_time", Type: flux.TTime}
valueCol := flux.ColMeta{Label: "_value", Type: flux.TString}
key := execute.NewGroupKey(nil, nil)
builder := execute.NewColListTableBuilder(key, &memory.Allocator{})
timeIdx, err := builder.AddCol(timeCol)
if err != nil {
return err
}
valueIdx, err := builder.AddCol(valueCol)
if err != nil {
return err
}
var eof bool
for !eof {
s, err := rd.reader.ReadString(rd.config.Separator)
if err != nil && err == io.EOF {
break
} else if err != nil {
return err
}
v := strings.Trim(s, string(rd.config.Separator))
ts := rd.config.TimeProvider.CurrentTime()
err = builder.AppendTime(timeIdx, ts)
if err != nil {
return err
}
err = builder.AppendString(valueIdx, v)
if err != nil {
return err
}
}
tbl, err := builder.Table()
if err != nil {
return err
}
rd.stats = tbl.Statistics()
return f(tbl)
}
func (*ResultDecoder) Name() string {
return "_result"
}
func (rd *ResultDecoder) Tables() flux.TableIterator {
return rd
}
func (rd *ResultDecoder) Statistics() flux.Statistics {
return rd.stats
}
func (rd *ResultDecoder) Decode(r io.Reader) (flux.Result, error) {
rd.reader = bufio.NewReader(r)
return rd, nil
} | line/result.go | 0.797517 | 0.405625 | result.go | starcoder |
package mxplatformgo
import (
"encoding/json"
)
// ChallengesResponseBody struct for ChallengesResponseBody
type ChallengesResponseBody struct {
Challenges []ChallengeResponse `json:"challenges,omitempty"`
Pagination *PaginationResponse `json:"pagination,omitempty"`
}
// NewChallengesResponseBody instantiates a new ChallengesResponseBody 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 NewChallengesResponseBody() *ChallengesResponseBody {
this := ChallengesResponseBody{}
return &this
}
// NewChallengesResponseBodyWithDefaults instantiates a new ChallengesResponseBody 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 NewChallengesResponseBodyWithDefaults() *ChallengesResponseBody {
this := ChallengesResponseBody{}
return &this
}
// GetChallenges returns the Challenges field value if set, zero value otherwise.
func (o *ChallengesResponseBody) GetChallenges() []ChallengeResponse {
if o == nil || o.Challenges == nil {
var ret []ChallengeResponse
return ret
}
return o.Challenges
}
// GetChallengesOk returns a tuple with the Challenges field value if set, nil otherwise
// and a boolean to check if the value has been set.
func (o *ChallengesResponseBody) GetChallengesOk() ([]ChallengeResponse, bool) {
if o == nil || o.Challenges == nil {
return nil, false
}
return o.Challenges, true
}
// HasChallenges returns a boolean if a field has been set.
func (o *ChallengesResponseBody) HasChallenges() bool {
if o != nil && o.Challenges != nil {
return true
}
return false
}
// SetChallenges gets a reference to the given []ChallengeResponse and assigns it to the Challenges field.
func (o *ChallengesResponseBody) SetChallenges(v []ChallengeResponse) {
o.Challenges = v
}
// GetPagination returns the Pagination field value if set, zero value otherwise.
func (o *ChallengesResponseBody) GetPagination() PaginationResponse {
if o == nil || o.Pagination == nil {
var ret PaginationResponse
return ret
}
return *o.Pagination
}
// GetPaginationOk returns a tuple with the Pagination field value if set, nil otherwise
// and a boolean to check if the value has been set.
func (o *ChallengesResponseBody) GetPaginationOk() (*PaginationResponse, bool) {
if o == nil || o.Pagination == nil {
return nil, false
}
return o.Pagination, true
}
// HasPagination returns a boolean if a field has been set.
func (o *ChallengesResponseBody) HasPagination() bool {
if o != nil && o.Pagination != nil {
return true
}
return false
}
// SetPagination gets a reference to the given PaginationResponse and assigns it to the Pagination field.
func (o *ChallengesResponseBody) SetPagination(v PaginationResponse) {
o.Pagination = &v
}
func (o ChallengesResponseBody) MarshalJSON() ([]byte, error) {
toSerialize := map[string]interface{}{}
if o.Challenges != nil {
toSerialize["challenges"] = o.Challenges
}
if o.Pagination != nil {
toSerialize["pagination"] = o.Pagination
}
return json.Marshal(toSerialize)
}
type NullableChallengesResponseBody struct {
value *ChallengesResponseBody
isSet bool
}
func (v NullableChallengesResponseBody) Get() *ChallengesResponseBody {
return v.value
}
func (v *NullableChallengesResponseBody) Set(val *ChallengesResponseBody) {
v.value = val
v.isSet = true
}
func (v NullableChallengesResponseBody) IsSet() bool {
return v.isSet
}
func (v *NullableChallengesResponseBody) Unset() {
v.value = nil
v.isSet = false
}
func NewNullableChallengesResponseBody(val *ChallengesResponseBody) *NullableChallengesResponseBody {
return &NullableChallengesResponseBody{value: val, isSet: true}
}
func (v NullableChallengesResponseBody) MarshalJSON() ([]byte, error) {
return json.Marshal(v.value)
}
func (v *NullableChallengesResponseBody) UnmarshalJSON(src []byte) error {
v.isSet = true
return json.Unmarshal(src, &v.value)
} | model_challenges_response_body.go | 0.741861 | 0.486941 | model_challenges_response_body.go | starcoder |
package assertlog
import (
"strings"
"time"
"github.com/stretchr/testify/assert"
)
type Source interface {
Logs() string
}
type TestingT interface {
Errorf(format string, args ...interface{})
FailNow()
}
type Service struct {
test TestingT
source func() string
curr func() string
ticker *time.Ticker
}
func New(source func() string, t TestingT) *Service {
return &Service{
source: source,
test: t,
curr: source,
ticker: time.NewTicker(time.Microsecond * 100),
}
}
func (s *Service) FromNow() *Service {
offset := len(s.curr())
return &Service{
source: s.curr,
test: s.test,
curr: func() string {
return s.curr()[offset:]
},
ticker: time.NewTicker(time.Microsecond * 100),
}
}
func (s *Service) Filter(f string) *Service {
return &Service{
source: s.curr,
test: s.test,
ticker: time.NewTicker(time.Microsecond * 100),
curr: func() string {
var filtered []string
lines := strings.Split(s.curr(), "\n")
for _, line := range lines {
if strings.Contains(line, f) {
filtered = append(filtered, line)
}
}
return strings.Join(filtered, "\n")
},
}
}
func (s *Service) WaitContains(expected string, timeout time.Duration) bool {
timer := time.NewTicker(timeout)
defer timer.Stop()
for {
select {
case <-timer.C:
return assert.Contains(s.test, s.curr(), expected, s.source())
case <-s.ticker.C:
if strings.Contains(s.curr(), expected) {
return true
}
}
}
}
func (s *Service) WaitNotContains(expected string, timeout time.Duration) bool {
timer := time.NewTicker(timeout)
defer timer.Stop()
for {
select {
case <-timer.C:
if assert.Contains(s.test, s.curr(), expected, s.source()) {
return false
}
case <-s.ticker.C:
return !strings.Contains(s.curr(), expected)
}
}
}
func (s *Service) WaitContainsOrFatal(expected string, timeout time.Duration) {
if !s.WaitContains(expected, timeout) {
s.test.FailNow()
}
}
func (s *Service) WaitNotContainsOrFatal(expected string, timeout time.Duration) {
if !s.WaitNotContains(expected, timeout) {
s.test.FailNow()
}
}
func (s *Service) NoErrors() bool {
if !assert.NotContains(s.test, s.curr(), "level=error", "failed assert that curr does not contain \"level=error\" word") {
return false
}
return s.NoPanicAndRace()
}
func (s *Service) NoPanic() bool {
return assert.NotContains(s.test, s.curr(), "panic", "failed assert that curr does not contain panic word")
}
func (s *Service) NoRace() bool {
return assert.NotContains(s.test, s.curr(), "DATA RACE", "failed assert that curr does not contain \"DATA RACE\" word")
}
func (s *Service) NoPanicAndRace() bool {
if !s.NoPanic() {
return false
}
if !s.NoRace() {
return false
}
return true
}
func (s *Service) Logs() string {
return s.curr()
}
func WaitContainsOrFatal(t TestingT, s func() string, expected string, timeout time.Duration) {
New(s, t).WaitContainsOrFatal(expected, timeout)
}
func WaitContains(t TestingT, s func() string, expected string, timeout time.Duration) bool {
return New(s, t).WaitContains(expected, timeout)
}
func WaitNotContains(t TestingT, s func() string, expected string, timeout time.Duration) bool {
return New(s, t).WaitNotContains(expected, timeout)
}
func WaitNotContainsOrFatal(t TestingT, s func() string, expected string, timeout time.Duration) {
New(s, t).WaitNotContainsOrFatal(expected, timeout)
} | test/pkg/assertlog/assertlog.go | 0.589362 | 0.432603 | assertlog.go | starcoder |
package jce
import (
"reflect"
"strconv"
"github.com/elap5e/penguin/pkg/bytes"
"github.com/elap5e/penguin/pkg/log"
)
func Marshal(v any, opts ...bool) ([]byte, error) {
simple := false
if len(opts) > 0 {
simple = opts[0]
}
e := &encoder{Buffer: bytes.NewBuffer([]byte{})}
err := e.marshal(v, simple)
if err != nil {
return nil, err
}
buf := append([]byte(nil), e.Bytes()...)
return buf, nil
}
type encoder struct {
*bytes.Buffer
}
func (e *encoder) marshal(v any, simple bool) error {
if !simple {
e.reflectValue(reflect.ValueOf(v), 0x00)
} else {
e.reflectValue(reflect.ValueOf(v), 0xff)
}
return nil
}
func isEmptyValue(v reflect.Value) bool {
switch v.Kind() {
case reflect.Array, reflect.Map, reflect.Slice, reflect.String:
return v.Len() == 0
case reflect.Bool:
return !v.Bool()
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return v.Int() == 0
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
return v.Uint() == 0
case reflect.Float32, reflect.Float64:
return v.Float() == 0
case reflect.Interface, reflect.Pointer:
return v.IsNil()
}
return false
}
func (e *encoder) reflectValue(v reflect.Value, t uint8) {
typeEncoder(v.Type())(e, v, t)
}
func (e *encoder) EncodeHead(v uint8, t uint8) {
if t < 15 {
e.WriteByte(v | t<<4)
} else {
e.WriteByte(v | 240)
e.WriteByte(t)
}
}
type encoderFunc func(e *encoder, v reflect.Value, t uint8)
func typeEncoder(t reflect.Type) encoderFunc {
switch t.Kind() {
case reflect.Bool:
return boolEncoder
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return intEncoder
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
return uintEncoder
case reflect.Float32, reflect.Float64:
return floatEncoder
case reflect.String:
return stringEncoder
case reflect.Interface:
return interfaceEncoder
case reflect.Struct:
return newStructEncoder(t)
case reflect.Map:
return newMapEncoder(t)
case reflect.Slice:
return newSliceEncoder(t)
case reflect.Array:
return newArrayEncoder(t)
case reflect.Pointer:
return newPtrEncoder(t)
default:
log.Panicln("unsupported type:", t)
return nil
}
}
func interfaceEncoder(e *encoder, v reflect.Value, t uint8) {
e.reflectValue(v.Elem(), t)
}
type ptrEncoder struct {
elemEnc encoderFunc
}
func (pe ptrEncoder) encode(e *encoder, v reflect.Value, t uint8) {
pe.elemEnc(e, v.Elem(), t)
}
func newPtrEncoder(t reflect.Type) encoderFunc {
enc := ptrEncoder{typeEncoder(t.Elem())}
return enc.encode
}
func bytesEncoder(e *encoder, v reflect.Value, t uint8) {
b := v.Bytes()
e.EncodeHead(0x0d, t)
e.EncodeHead(0x00, 0x00)
intEncoder(e, reflect.ValueOf(len(b)), 0x00)
e.Write(b)
}
type sliceEncoder struct {
arrayEnc encoderFunc
}
func (se sliceEncoder) encode(e *encoder, v reflect.Value, t uint8) {
se.arrayEnc(e, v, t)
}
func newSliceEncoder(t reflect.Type) encoderFunc {
if t.Elem().Kind() == reflect.Uint8 {
return bytesEncoder
}
enc := sliceEncoder{newArrayEncoder(t)}
return enc.encode
}
type field struct {
name string
tag uint8
index []int
typ reflect.Type
omitEmpty bool
encoder encoderFunc
}
type structFields struct {
list []field
tagIndex map[uint8]int
}
func typeFields(t reflect.Type) structFields {
current := []field{}
next := []field{{typ: t}}
var count, nextCount map[reflect.Type]int
var fields []field
for len(next) > 0 {
current, next = next, current[:0]
count, nextCount = nextCount, map[reflect.Type]int{}
for _, f := range current {
for i := 0; i < f.typ.NumField(); i++ {
sf := f.typ.Field(i)
tag := sf.Tag.Get("jce")
if tag == "" {
continue
}
name, opts := parseTag(sf.Tag.Get("json"))
if name == "" {
name = sf.Name
}
index := make([]int, len(f.index)+1)
copy(index, f.index)
index[len(f.index)] = i
ft := sf.Type
if ft.Kind() != reflect.Struct {
t, _ := strconv.ParseUint(tag, 10, 8)
field := field{
name: name,
tag: uint8(t),
index: index,
typ: ft,
omitEmpty: opts.Contains("omitempty"),
}
fields = append(fields, field)
if count[f.typ] > 1 {
fields = append(fields, fields[len(fields)-1])
}
continue
}
nextCount[ft]++
if nextCount[ft] == 1 {
next = append(next, field{name: ft.Name(), index: index, typ: ft})
}
}
}
}
for i := range fields {
f := &fields[i]
f.encoder = typeEncoder(typeByIndex(t, f.index))
}
tagIndex := make(map[uint8]int, len(fields))
for i, field := range fields {
tagIndex[field.tag] = i
}
return structFields{fields, tagIndex}
}
func typeByIndex(t reflect.Type, index []int) reflect.Type {
for _, i := range index {
if t.Kind() == reflect.Ptr {
t = t.Elem()
}
t = t.Field(i).Type
}
return t
}
type structEncoder struct {
fields structFields
}
func (se structEncoder) encode(e *encoder, v reflect.Value, t uint8) {
if t != 0xff {
e.EncodeHead(0x0a, t)
defer e.EncodeHead(0x0b, 0x00)
}
for i := range se.fields.list {
f := &se.fields.list[i]
fv := v.Field(i)
if f.omitEmpty && isEmptyValue(fv) {
continue
}
f.encoder(e, fv, f.tag)
}
}
func newStructEncoder(t reflect.Type) encoderFunc {
se := structEncoder{fields: typeFields(t)}
return se.encode
}
type arrayEncoder struct {
elemEnc encoderFunc
}
func (ae arrayEncoder) encode(e *encoder, v reflect.Value, t uint8) {
e.EncodeHead(0x09, t)
l := v.Len()
intEncoder(e, reflect.ValueOf(l), 0x00)
for i := 0; i < l; i++ {
ae.elemEnc(e, v.Index(i), 0x00)
}
}
func newArrayEncoder(t reflect.Type) encoderFunc {
enc := arrayEncoder{typeEncoder(t.Elem())}
return enc.encode
}
type mapEncoder struct {
elemEnc encoderFunc
}
func (me mapEncoder) encode(e *encoder, v reflect.Value, t uint8) {
ks := v.MapKeys()
e.EncodeHead(0x08, t)
intEncoder(e, reflect.ValueOf(len(ks)), 0x00)
for _, k := range ks {
b := v.MapIndex(k)
stringEncoder(e, k, 0x00)
me.elemEnc(e, b, 0x01)
}
}
func newMapEncoder(t reflect.Type) encoderFunc {
me := mapEncoder{typeEncoder(t.Elem())}
return me.encode
}
func stringEncoder(e *encoder, v reflect.Value, t uint8) {
b := v.String()
l := len(b)
if l > 255 {
e.EncodeHead(0x07, t)
intEncoder(e, reflect.ValueOf(len(b)), 0x00)
e.WriteString(b)
return
}
e.EncodeHead(0x06, t)
e.WriteByte(uint8(l))
e.WriteString(b)
}
func floatEncoder(e *encoder, v reflect.Value, t uint8) {
k := v.Kind()
b := v.Float()
switch k {
case reflect.Float64:
e.EncodeHead(0x05, t)
e.WriteFloat64(b)
case reflect.Float32:
e.EncodeHead(0x04, t)
e.WriteFloat32(float32(b))
}
}
func intEncoder(e *encoder, v reflect.Value, t uint8) {
k := v.Kind()
b := v.Int()
switch k {
case reflect.Int64:
if b>>31 != 0 {
e.EncodeHead(0x03, t)
e.WriteInt64(b)
return
}
fallthrough
case reflect.Int32, reflect.Int:
if b>>15 != 0 {
e.EncodeHead(0x02, t)
e.WriteInt32(int32(b))
return
}
fallthrough
case reflect.Int16:
if b>>7 != 0 {
e.EncodeHead(0x01, t)
e.WriteInt16(int16(b))
return
}
fallthrough
case reflect.Int8:
if b != 0 {
e.EncodeHead(0x00, t)
e.WriteByte(byte(b))
return
}
e.EncodeHead(0x0c, t)
}
}
func uintEncoder(e *encoder, v reflect.Value, t uint8) {
k := v.Kind()
b := v.Uint()
switch k {
case reflect.Uint64:
if b>>31 != 0 {
e.EncodeHead(0x03, t)
e.WriteUint64(b)
return
}
fallthrough
case reflect.Uint32, reflect.Uint:
if b>>15 != 0 {
e.EncodeHead(0x02, t)
e.WriteUint32(uint32(b))
return
}
fallthrough
case reflect.Uint16:
if b>>7 != 0 {
e.EncodeHead(0x01, t)
e.WriteUint16(uint16(b))
return
}
fallthrough
case reflect.Uint8:
if b != 0 {
e.EncodeHead(0x00, t)
e.WriteByte(byte(b))
return
}
e.EncodeHead(0x0c, t)
default:
log.Panicln("unsupported type:", t)
}
}
func boolEncoder(e *encoder, v reflect.Value, t uint8) {
if v.Bool() {
e.EncodeHead(0x00, t)
e.WriteByte(0x01)
return
}
e.EncodeHead(0x0c, t)
} | pkg/encoding/jce/encode.go | 0.532425 | 0.474692 | encode.go | starcoder |
package xydata
import (
"github.com/Akkurate/utils/numf"
"github.com/Akkurate/utils/numi"
)
// Length of data
func (xy *XY) Len() int {
xy.Error = ""
return len(xy.Map)
}
// Replaces XY pair from given index.
func (xy *XY) ReplaceXY(x, y float64, i int) {
if xy.isBadindexing(i) {
return
}
xy.data[xy.Map[i]] = xypair{x: x, y: y, i: i}
}
// Adds XY pair to the tail of data array.
func (xy *XY) AddXY(x, y float64) {
xy.Error = ""
newindex := len(xy.data)
xy.data = append(xy.data, xypair{x: x, y: y, i: newindex})
xy.Map = append(xy.Map, newindex)
}
// Inserts XY pair into data array.
func (xy *XY) InsertXY(x, y float64, i int) {
// i index points to Map -- we need to figure out the index to real data
// strategy is to insert to higher real index, if ambiguous
reali := xy.Map[i] // default real index
if i > 0 {
if xy.Map[i-1] > xy.Map[i] {
reali = xy.Map[i-1]
}
}
xy.data = append(xy.data, xypair{})
copy(xy.data[reali+1:], xy.data[reali:])
xy.data[reali] = xypair{x: x, y: y, i: reali}
// update index within pairs
for x, p := range xy.data[reali+1:] {
p.i = p.i + 1
xy.data[reali+1+x] = p
}
// update map to reflect inserting
for i, v := range xy.Map {
if v >= reali {
xy.Map[i] = v + 1
}
}
xy.Map = numi.Insert(xy.Map, i, reali)
}
// Removes XY pair from given index. Note that this actually removes the data, not just the index to it.
func (xy *XY) RemoveXY(i int) {
if xy.isBadindexing(i) {
return
}
reali := xy.Map[i] // get the index to real data...
xy.data = append(xy.data[:reali], xy.data[reali+1:]...)
// update map to reflect removing
for i, v := range xy.Map {
if v > reali {
xy.Map[i] = v - 1
}
}
xy.Map = append(xy.Map[:i], xy.Map[i+1:]...)
}
// Returns X and Y from given index
func (xy *XY) GetXY(i int) (x, y float64) {
if xy.isBadindexing(i) {
return
}
return xy.data[xy.Map[i]].x, xy.data[xy.Map[i]].y
}
// Returns X from given index
func (xy *XY) GetX(i int) (x float64) {
if xy.isBadindexing(i) {
return
}
return xy.data[xy.Map[i]].x
}
// Returns Y from given index
func (xy *XY) GetY(i int) (y float64) {
if xy.isBadindexing(i) {
return
}
return xy.data[xy.Map[i]].y
}
// Finds the index of given X and/or Y value(s). Index is gone through in ascending order and the first match is returned.
// Use math.NaN() to disable matching. Function returns -1 is not match is found.
func (xy *XY) FindIndex(x, y float64) int {
xy.Error = ""
matchboth := numf.IsValid(x) && numf.IsValid(y)
for i, v := range xy.Map {
p := xy.data[v]
switch matchboth {
case true:
if p.x == x && p.y == y {
return i
}
case false:
if p.x == x || p.y == y {
return i
}
}
}
return -1
} | xydata/basic.go | 0.679817 | 0.507873 | basic.go | starcoder |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.