// NewInputField returns a new input field.
503276
func NewInputField() *InputField {
	return &InputField{
		Box:                  NewBox(),
		labelColor:           Styles.SecondaryTextColor,
		fieldBackgroundColor: Styles.ContrastBackgroundColor,
		fieldTextColor:       Styles.PrimaryTextColor,
		placeholderTextColor: Styles.ContrastSecondaryTextColor,
	}
}
999463
func NewField(poly, α int) *Field {
	if poly < 0x100 || poly >= 0x200 || reducible(poly) {
		panic("gf256: invalid polynomial: " + strconv.Itoa(poly))
	}

	var f Field
	x := 1
	for i := 0; i < 255; i++ {
		if x == 1 && i != 0 {
			panic("gf256: invalid generator " + strconv.Itoa(α) +
				" for polynomial " + strconv.Itoa(poly))
		}
		f.exp[i] = byte(x)
		f.exp[i+255] = byte(x)
		f.log[x] = byte(i)
		x = mul(x, α, poly)
	}
	f.log[0] = 255
	for i := 0; i < 255; i++ {
		if f.log[f.exp[i]] != byte(i) {
			panic("bad log")
		}
		if f.log[f.exp[i+255]] != byte(i) {
			panic("bad log")
		}
	}
	for i := 1; i < 256; i++ {
		if f.exp[f.log[i]] != byte(i) {
			panic("bad log")
		}
	}

	return &f
}
1194406
func NewInputCodBarRow(id, label, value string) *Row {
	row := NewRow()
	div := elements.Panel{}
	div.AddClass("input-field col s8")

	input := elements.InputText{}
	input.ID = id
	input.AddClass("validate")
	input.SetData("placeholder", label)
	input.SetData("value", value)
	input.SetData("name", id)
	lab := Label{For: input.ID,
		Text: label}

	btn := elements.Link{Text: "CodBar",
		URL: "javascript:Coletor.startLeitorCodigoBarras()"}
	btn.AddClass("waves-effect")
	btn.AddClass("waves-light")
	btn.AddClass("btn")

	div.AddElement(input)
	div.AddElement(lab)
	row.AddElement(div)
	row.AddElement(btn)

	return row
}
467200
func (s *LambdaFunctionScheduledEventAttributes) SetInput(v string) *LambdaFunctionScheduledEventAttributes {
	s.Input = &v
	return s
}
984465
func (s *CreateStreamProcessorInput) SetInput(v *StreamProcessorInput) *CreateStreamProcessorInput {
	s.Input = v
	return s
}
462542
func (s *AacSettings) SetInputType(v string) *AacSettings {
	s.InputType = &v
	return s
}
876808
func (s *ActivityScheduledEventDetails) SetInput(v string) *ActivityScheduledEventDetails {
	s.Input = &v
	return s
}
622866
func New(message string, field string, kind Kind) Error {
	return Error{message, field, 0, kind}
}
805458
func NewInputGuard(ports ...string) *InputGuard {
	portMap := make(map[string]bool, len(ports))
	for _, p := range ports {
		portMap[p] = false
	}
	return &InputGuard{portMap, 0}
}
985037
func (s *Input) SetInputClass(v string) *Input {
	s.InputClass = &v
	return s
}
138567
func NewField(owner *Struct, field *toolbox.FieldInfo, fieldType *toolbox.TypeInfo) (*Field, error) {
	typeName := normalizeTypeName(field.TypeName)
	var result = &Field{
		IsAnonymous:        field.IsAnonymous,
		Name:               field.Name,
		RawType:            field.TypeName,
		IsPointer:          field.IsPointer,
		Key:                getJSONKey(owner.options, field),
		Receiver:           owner.Alias + " *" + owner.TypeInfo.Name,
		Type:               typeName,
		Mutator:            owner.Alias + "." + field.Name,
		Accessor:           owner.Alias + "." + field.Name,
		ComponentType:      field.ComponentType,
		IsPointerComponent: field.IsPointerComponent,
		Var:                firstLetterToLowercase(field.Name),
		Init:               fmt.Sprintf("%v{}", typeName),
		TimeLayout:         "time.RFC3339",
		IsSlice:            field.IsSlice,
		PoolName:           getPoolName(field.TypeName),
		Alias:              owner.Alias,
		Reset:              "nil",
	}
	var err error
	if field.IsPointer {
		result.DereferenceModifier = "*"
		result.Init = "&" + result.Init
	} else {
		result.PointerModifier = "&"

	}
	if field.IsSlice {
		result.HelperType = getSliceHelperTypeName(field.ComponentType, field.IsPointerComponent)
		result.PoolName = getPoolName(field.ComponentType)
	} else if fieldType != nil {
		result.HelperType = getSliceHelperTypeName(fieldType.Name, field.IsPointerComponent)
	}

	if options := getTagOptions(field.Tag, "timeLayout"); len(options) > 0 {
		result.TimeLayout = wrapperIfNeeded(options[0], `"`)
	} else if options := getTagOptions(field.Tag, "timeFormat"); len(options) > 0 {
		result.TimeLayout = wrapperIfNeeded(toolbox.DateFormatToLayout(options[0]), `"`)
	}
	if strings.Contains(field.Tag, "omitempty") {
		result.OmitEmpty = "OmitEmpty"
	}
	if strings.Contains(field.Tag, "nullempty") {
		result.OmitEmpty = "NullEmpty"
	}

	if owner.options.PoolObjects {
		if field.IsPointer && !strings.HasSuffix(field.TypeName, ".Time") && !strings.Contains(field.TypeName, "sql.Null") {
			poolName := getPoolName(field.TypeName)
			result.Init = fmt.Sprintf(`%v.Get().(*%v)`, poolName, field.TypeName)
		}
	}

	encodingMethod := field.ComponentType
	if encodingMethod == "" {
		encodingMethod = result.Type
	}
	result.DecodingMethod = firstLetterToUppercase(encodingMethod)
	result.EncodingMethod = firstLetterToUppercase(encodingMethod)

	switch typeName {
	case "int", "int8", "int16", "int32", "int64", "uint", "uint8", "uint16", "uint32", "uint64":
		result.Reset = "0"
	case "float32", "float64":
		result.Reset = "0.0"
	case "string":
		result.Reset = `""`

	case "bool":
		result.Reset = "false"
	default:
		if field.IsSlice && owner.Type(field.ComponentType) != nil {
			var itemPointer = ""
			if !field.IsPointerComponent {
				itemPointer = "&"
			}
			result.ResetDependency, err = expandFieldTemplate(poolSliceInstanceRelease, struct {
				PoolName        string
				Accessor        string
				PointerModifier string
			}{PoolName: result.PoolName, Accessor: result.Accessor, PointerModifier: itemPointer})
			if err != nil {
				return nil, err
			}

		} else if field.IsPointer && fieldType != nil {
			result.ResetDependency, err = expandFieldTemplate(poolInstanceRelease, struct {
				PoolName string
				Accessor string
			}{PoolName: result.PoolName, Accessor: result.Accessor})
			if err != nil {
				return nil, err
			}
		}

	}
	if field.IsSlice || field.IsPointer {
		result.Reset = "nil"
	}

	if result.IsPointerComponent {
		result.ComponentInit = "&" + result.ComponentType + "{}"
		result.RawComponentType = "*" + result.ComponentType

		result.ComponentDereferenceModifier = "*"
		result.ComponentInitModifier = "&"

	} else {
		result.ComponentInit = result.ComponentType + "{}"
		result.RawComponentType = result.ComponentType

		result.ComponentPointerModifier = "&"
	}

	return result, nil
}
443528
func newFieldType() *FieldType {
	return &FieldType{
		_tokenized:           true,
		_indexOptions:        model.INDEX_OPT_DOCS_AND_FREQS_AND_POSITIONS,
		numericPrecisionStep: util.NUMERIC_PRECISION_STEP_DEFAULT,
	}
}
756839
func (s *MotionImageInserter) SetInput(v string) *MotionImageInserter {
	s.Input = &v
	return s
}
992266
func AddInputs(inputs ...InputWithScript) UpdateOption {
	return func(uo *updateOptions) {
		uo.inputs = append(uo.inputs, inputs...)
	}
}
1026827
func (s *DescribeExecutionOutput) SetInput(v string) *DescribeExecutionOutput {
	s.Input = &v
	return s
}
1334121
func New(input string) *Scanner {
	// Normalize newlines.
	// https://www.w3.org/TR/css-syntax-3/#input-preprocessing
	input = strings.Replace(input, "\r\n", "\n", -1)
	input = strings.Replace(input, "\r", "\n", -1)
	input = strings.Replace(input, "\f", "\n", -1)
	input = strings.Replace(input, "\u0000", "\ufffd", -1)
	return &Scanner{
		input: input,
		row:   1,
		col:   1,
	}
}
1167265
func NewInvalidError(field *FieldPath, value interface{}, detail string) *Error {
	return &Error{ErrorTypeInvalid, field.String(), value, detail}
}