//------------------------------------------------------------------------------
// Automatically generated by the Fast Binary Encoding compiler, do not modify!
// https://github.com/chronoxor/FastBinaryEncoding
// Source: enums.fbe
// FBE version: 1.15.0.0
//------------------------------------------------------------------------------

package enums

import "errors"
import "../fbe"

// Workaround for Go unused imports issue
var _ = errors.New
var _ = fbe.Version

// Fast Binary Encoding Enums field model
type FieldModelEnums struct {
    // Field model buffer
    buffer *fbe.Buffer
    // Field model buffer offset
    offset int

    Byte0 *FieldModelEnumByte
    Byte1 *FieldModelEnumByte
    Byte2 *FieldModelEnumByte
    Byte3 *FieldModelEnumByte
    Byte4 *FieldModelEnumByte
    Byte5 *FieldModelEnumByte
    Char0 *FieldModelEnumChar
    Char1 *FieldModelEnumChar
    Char2 *FieldModelEnumChar
    Char3 *FieldModelEnumChar
    Char4 *FieldModelEnumChar
    Char5 *FieldModelEnumChar
    Wchar0 *FieldModelEnumWChar
    Wchar1 *FieldModelEnumWChar
    Wchar2 *FieldModelEnumWChar
    Wchar3 *FieldModelEnumWChar
    Wchar4 *FieldModelEnumWChar
    Wchar5 *FieldModelEnumWChar
    Int8b0 *FieldModelEnumInt8
    Int8b1 *FieldModelEnumInt8
    Int8b2 *FieldModelEnumInt8
    Int8b3 *FieldModelEnumInt8
    Int8b4 *FieldModelEnumInt8
    Int8b5 *FieldModelEnumInt8
    Uint8b0 *FieldModelEnumUInt8
    Uint8b1 *FieldModelEnumUInt8
    Uint8b2 *FieldModelEnumUInt8
    Uint8b3 *FieldModelEnumUInt8
    Uint8b4 *FieldModelEnumUInt8
    Uint8b5 *FieldModelEnumUInt8
    Int16b0 *FieldModelEnumInt16
    Int16b1 *FieldModelEnumInt16
    Int16b2 *FieldModelEnumInt16
    Int16b3 *FieldModelEnumInt16
    Int16b4 *FieldModelEnumInt16
    Int16b5 *FieldModelEnumInt16
    Uint16b0 *FieldModelEnumUInt16
    Uint16b1 *FieldModelEnumUInt16
    Uint16b2 *FieldModelEnumUInt16
    Uint16b3 *FieldModelEnumUInt16
    Uint16b4 *FieldModelEnumUInt16
    Uint16b5 *FieldModelEnumUInt16
    Int32b0 *FieldModelEnumInt32
    Int32b1 *FieldModelEnumInt32
    Int32b2 *FieldModelEnumInt32
    Int32b3 *FieldModelEnumInt32
    Int32b4 *FieldModelEnumInt32
    Int32b5 *FieldModelEnumInt32
    Uint32b0 *FieldModelEnumUInt32
    Uint32b1 *FieldModelEnumUInt32
    Uint32b2 *FieldModelEnumUInt32
    Uint32b3 *FieldModelEnumUInt32
    Uint32b4 *FieldModelEnumUInt32
    Uint32b5 *FieldModelEnumUInt32
    Int64b0 *FieldModelEnumInt64
    Int64b1 *FieldModelEnumInt64
    Int64b2 *FieldModelEnumInt64
    Int64b3 *FieldModelEnumInt64
    Int64b4 *FieldModelEnumInt64
    Int64b5 *FieldModelEnumInt64
    Uint64b0 *FieldModelEnumUInt64
    Uint64b1 *FieldModelEnumUInt64
    Uint64b2 *FieldModelEnumUInt64
    Uint64b3 *FieldModelEnumUInt64
    Uint64b4 *FieldModelEnumUInt64
    Uint64b5 *FieldModelEnumUInt64
}

// Create a new Enums field model
func NewFieldModelEnums(buffer *fbe.Buffer, offset int) *FieldModelEnums {
    fbeResult := FieldModelEnums{buffer: buffer, offset: offset}
    fbeResult.Byte0 = NewFieldModelEnumByte(buffer, 4 + 4)
    fbeResult.Byte1 = NewFieldModelEnumByte(buffer, fbeResult.Byte0.FBEOffset() + fbeResult.Byte0.FBESize())
    fbeResult.Byte2 = NewFieldModelEnumByte(buffer, fbeResult.Byte1.FBEOffset() + fbeResult.Byte1.FBESize())
    fbeResult.Byte3 = NewFieldModelEnumByte(buffer, fbeResult.Byte2.FBEOffset() + fbeResult.Byte2.FBESize())
    fbeResult.Byte4 = NewFieldModelEnumByte(buffer, fbeResult.Byte3.FBEOffset() + fbeResult.Byte3.FBESize())
    fbeResult.Byte5 = NewFieldModelEnumByte(buffer, fbeResult.Byte4.FBEOffset() + fbeResult.Byte4.FBESize())
    fbeResult.Char0 = NewFieldModelEnumChar(buffer, fbeResult.Byte5.FBEOffset() + fbeResult.Byte5.FBESize())
    fbeResult.Char1 = NewFieldModelEnumChar(buffer, fbeResult.Char0.FBEOffset() + fbeResult.Char0.FBESize())
    fbeResult.Char2 = NewFieldModelEnumChar(buffer, fbeResult.Char1.FBEOffset() + fbeResult.Char1.FBESize())
    fbeResult.Char3 = NewFieldModelEnumChar(buffer, fbeResult.Char2.FBEOffset() + fbeResult.Char2.FBESize())
    fbeResult.Char4 = NewFieldModelEnumChar(buffer, fbeResult.Char3.FBEOffset() + fbeResult.Char3.FBESize())
    fbeResult.Char5 = NewFieldModelEnumChar(buffer, fbeResult.Char4.FBEOffset() + fbeResult.Char4.FBESize())
    fbeResult.Wchar0 = NewFieldModelEnumWChar(buffer, fbeResult.Char5.FBEOffset() + fbeResult.Char5.FBESize())
    fbeResult.Wchar1 = NewFieldModelEnumWChar(buffer, fbeResult.Wchar0.FBEOffset() + fbeResult.Wchar0.FBESize())
    fbeResult.Wchar2 = NewFieldModelEnumWChar(buffer, fbeResult.Wchar1.FBEOffset() + fbeResult.Wchar1.FBESize())
    fbeResult.Wchar3 = NewFieldModelEnumWChar(buffer, fbeResult.Wchar2.FBEOffset() + fbeResult.Wchar2.FBESize())
    fbeResult.Wchar4 = NewFieldModelEnumWChar(buffer, fbeResult.Wchar3.FBEOffset() + fbeResult.Wchar3.FBESize())
    fbeResult.Wchar5 = NewFieldModelEnumWChar(buffer, fbeResult.Wchar4.FBEOffset() + fbeResult.Wchar4.FBESize())
    fbeResult.Int8b0 = NewFieldModelEnumInt8(buffer, fbeResult.Wchar5.FBEOffset() + fbeResult.Wchar5.FBESize())
    fbeResult.Int8b1 = NewFieldModelEnumInt8(buffer, fbeResult.Int8b0.FBEOffset() + fbeResult.Int8b0.FBESize())
    fbeResult.Int8b2 = NewFieldModelEnumInt8(buffer, fbeResult.Int8b1.FBEOffset() + fbeResult.Int8b1.FBESize())
    fbeResult.Int8b3 = NewFieldModelEnumInt8(buffer, fbeResult.Int8b2.FBEOffset() + fbeResult.Int8b2.FBESize())
    fbeResult.Int8b4 = NewFieldModelEnumInt8(buffer, fbeResult.Int8b3.FBEOffset() + fbeResult.Int8b3.FBESize())
    fbeResult.Int8b5 = NewFieldModelEnumInt8(buffer, fbeResult.Int8b4.FBEOffset() + fbeResult.Int8b4.FBESize())
    fbeResult.Uint8b0 = NewFieldModelEnumUInt8(buffer, fbeResult.Int8b5.FBEOffset() + fbeResult.Int8b5.FBESize())
    fbeResult.Uint8b1 = NewFieldModelEnumUInt8(buffer, fbeResult.Uint8b0.FBEOffset() + fbeResult.Uint8b0.FBESize())
    fbeResult.Uint8b2 = NewFieldModelEnumUInt8(buffer, fbeResult.Uint8b1.FBEOffset() + fbeResult.Uint8b1.FBESize())
    fbeResult.Uint8b3 = NewFieldModelEnumUInt8(buffer, fbeResult.Uint8b2.FBEOffset() + fbeResult.Uint8b2.FBESize())
    fbeResult.Uint8b4 = NewFieldModelEnumUInt8(buffer, fbeResult.Uint8b3.FBEOffset() + fbeResult.Uint8b3.FBESize())
    fbeResult.Uint8b5 = NewFieldModelEnumUInt8(buffer, fbeResult.Uint8b4.FBEOffset() + fbeResult.Uint8b4.FBESize())
    fbeResult.Int16b0 = NewFieldModelEnumInt16(buffer, fbeResult.Uint8b5.FBEOffset() + fbeResult.Uint8b5.FBESize())
    fbeResult.Int16b1 = NewFieldModelEnumInt16(buffer, fbeResult.Int16b0.FBEOffset() + fbeResult.Int16b0.FBESize())
    fbeResult.Int16b2 = NewFieldModelEnumInt16(buffer, fbeResult.Int16b1.FBEOffset() + fbeResult.Int16b1.FBESize())
    fbeResult.Int16b3 = NewFieldModelEnumInt16(buffer, fbeResult.Int16b2.FBEOffset() + fbeResult.Int16b2.FBESize())
    fbeResult.Int16b4 = NewFieldModelEnumInt16(buffer, fbeResult.Int16b3.FBEOffset() + fbeResult.Int16b3.FBESize())
    fbeResult.Int16b5 = NewFieldModelEnumInt16(buffer, fbeResult.Int16b4.FBEOffset() + fbeResult.Int16b4.FBESize())
    fbeResult.Uint16b0 = NewFieldModelEnumUInt16(buffer, fbeResult.Int16b5.FBEOffset() + fbeResult.Int16b5.FBESize())
    fbeResult.Uint16b1 = NewFieldModelEnumUInt16(buffer, fbeResult.Uint16b0.FBEOffset() + fbeResult.Uint16b0.FBESize())
    fbeResult.Uint16b2 = NewFieldModelEnumUInt16(buffer, fbeResult.Uint16b1.FBEOffset() + fbeResult.Uint16b1.FBESize())
    fbeResult.Uint16b3 = NewFieldModelEnumUInt16(buffer, fbeResult.Uint16b2.FBEOffset() + fbeResult.Uint16b2.FBESize())
    fbeResult.Uint16b4 = NewFieldModelEnumUInt16(buffer, fbeResult.Uint16b3.FBEOffset() + fbeResult.Uint16b3.FBESize())
    fbeResult.Uint16b5 = NewFieldModelEnumUInt16(buffer, fbeResult.Uint16b4.FBEOffset() + fbeResult.Uint16b4.FBESize())
    fbeResult.Int32b0 = NewFieldModelEnumInt32(buffer, fbeResult.Uint16b5.FBEOffset() + fbeResult.Uint16b5.FBESize())
    fbeResult.Int32b1 = NewFieldModelEnumInt32(buffer, fbeResult.Int32b0.FBEOffset() + fbeResult.Int32b0.FBESize())
    fbeResult.Int32b2 = NewFieldModelEnumInt32(buffer, fbeResult.Int32b1.FBEOffset() + fbeResult.Int32b1.FBESize())
    fbeResult.Int32b3 = NewFieldModelEnumInt32(buffer, fbeResult.Int32b2.FBEOffset() + fbeResult.Int32b2.FBESize())
    fbeResult.Int32b4 = NewFieldModelEnumInt32(buffer, fbeResult.Int32b3.FBEOffset() + fbeResult.Int32b3.FBESize())
    fbeResult.Int32b5 = NewFieldModelEnumInt32(buffer, fbeResult.Int32b4.FBEOffset() + fbeResult.Int32b4.FBESize())
    fbeResult.Uint32b0 = NewFieldModelEnumUInt32(buffer, fbeResult.Int32b5.FBEOffset() + fbeResult.Int32b5.FBESize())
    fbeResult.Uint32b1 = NewFieldModelEnumUInt32(buffer, fbeResult.Uint32b0.FBEOffset() + fbeResult.Uint32b0.FBESize())
    fbeResult.Uint32b2 = NewFieldModelEnumUInt32(buffer, fbeResult.Uint32b1.FBEOffset() + fbeResult.Uint32b1.FBESize())
    fbeResult.Uint32b3 = NewFieldModelEnumUInt32(buffer, fbeResult.Uint32b2.FBEOffset() + fbeResult.Uint32b2.FBESize())
    fbeResult.Uint32b4 = NewFieldModelEnumUInt32(buffer, fbeResult.Uint32b3.FBEOffset() + fbeResult.Uint32b3.FBESize())
    fbeResult.Uint32b5 = NewFieldModelEnumUInt32(buffer, fbeResult.Uint32b4.FBEOffset() + fbeResult.Uint32b4.FBESize())
    fbeResult.Int64b0 = NewFieldModelEnumInt64(buffer, fbeResult.Uint32b5.FBEOffset() + fbeResult.Uint32b5.FBESize())
    fbeResult.Int64b1 = NewFieldModelEnumInt64(buffer, fbeResult.Int64b0.FBEOffset() + fbeResult.Int64b0.FBESize())
    fbeResult.Int64b2 = NewFieldModelEnumInt64(buffer, fbeResult.Int64b1.FBEOffset() + fbeResult.Int64b1.FBESize())
    fbeResult.Int64b3 = NewFieldModelEnumInt64(buffer, fbeResult.Int64b2.FBEOffset() + fbeResult.Int64b2.FBESize())
    fbeResult.Int64b4 = NewFieldModelEnumInt64(buffer, fbeResult.Int64b3.FBEOffset() + fbeResult.Int64b3.FBESize())
    fbeResult.Int64b5 = NewFieldModelEnumInt64(buffer, fbeResult.Int64b4.FBEOffset() + fbeResult.Int64b4.FBESize())
    fbeResult.Uint64b0 = NewFieldModelEnumUInt64(buffer, fbeResult.Int64b5.FBEOffset() + fbeResult.Int64b5.FBESize())
    fbeResult.Uint64b1 = NewFieldModelEnumUInt64(buffer, fbeResult.Uint64b0.FBEOffset() + fbeResult.Uint64b0.FBESize())
    fbeResult.Uint64b2 = NewFieldModelEnumUInt64(buffer, fbeResult.Uint64b1.FBEOffset() + fbeResult.Uint64b1.FBESize())
    fbeResult.Uint64b3 = NewFieldModelEnumUInt64(buffer, fbeResult.Uint64b2.FBEOffset() + fbeResult.Uint64b2.FBESize())
    fbeResult.Uint64b4 = NewFieldModelEnumUInt64(buffer, fbeResult.Uint64b3.FBEOffset() + fbeResult.Uint64b3.FBESize())
    fbeResult.Uint64b5 = NewFieldModelEnumUInt64(buffer, fbeResult.Uint64b4.FBEOffset() + fbeResult.Uint64b4.FBESize())
    return &fbeResult
}

// Get the field size
func (fm *FieldModelEnums) FBESize() int { return 4 }

// Get the field body size
func (fm *FieldModelEnums) FBEBody() int {
    fbeResult := 4 + 4 +
        fm.Byte0.FBESize() +
        fm.Byte1.FBESize() +
        fm.Byte2.FBESize() +
        fm.Byte3.FBESize() +
        fm.Byte4.FBESize() +
        fm.Byte5.FBESize() +
        fm.Char0.FBESize() +
        fm.Char1.FBESize() +
        fm.Char2.FBESize() +
        fm.Char3.FBESize() +
        fm.Char4.FBESize() +
        fm.Char5.FBESize() +
        fm.Wchar0.FBESize() +
        fm.Wchar1.FBESize() +
        fm.Wchar2.FBESize() +
        fm.Wchar3.FBESize() +
        fm.Wchar4.FBESize() +
        fm.Wchar5.FBESize() +
        fm.Int8b0.FBESize() +
        fm.Int8b1.FBESize() +
        fm.Int8b2.FBESize() +
        fm.Int8b3.FBESize() +
        fm.Int8b4.FBESize() +
        fm.Int8b5.FBESize() +
        fm.Uint8b0.FBESize() +
        fm.Uint8b1.FBESize() +
        fm.Uint8b2.FBESize() +
        fm.Uint8b3.FBESize() +
        fm.Uint8b4.FBESize() +
        fm.Uint8b5.FBESize() +
        fm.Int16b0.FBESize() +
        fm.Int16b1.FBESize() +
        fm.Int16b2.FBESize() +
        fm.Int16b3.FBESize() +
        fm.Int16b4.FBESize() +
        fm.Int16b5.FBESize() +
        fm.Uint16b0.FBESize() +
        fm.Uint16b1.FBESize() +
        fm.Uint16b2.FBESize() +
        fm.Uint16b3.FBESize() +
        fm.Uint16b4.FBESize() +
        fm.Uint16b5.FBESize() +
        fm.Int32b0.FBESize() +
        fm.Int32b1.FBESize() +
        fm.Int32b2.FBESize() +
        fm.Int32b3.FBESize() +
        fm.Int32b4.FBESize() +
        fm.Int32b5.FBESize() +
        fm.Uint32b0.FBESize() +
        fm.Uint32b1.FBESize() +
        fm.Uint32b2.FBESize() +
        fm.Uint32b3.FBESize() +
        fm.Uint32b4.FBESize() +
        fm.Uint32b5.FBESize() +
        fm.Int64b0.FBESize() +
        fm.Int64b1.FBESize() +
        fm.Int64b2.FBESize() +
        fm.Int64b3.FBESize() +
        fm.Int64b4.FBESize() +
        fm.Int64b5.FBESize() +
        fm.Uint64b0.FBESize() +
        fm.Uint64b1.FBESize() +
        fm.Uint64b2.FBESize() +
        fm.Uint64b3.FBESize() +
        fm.Uint64b4.FBESize() +
        fm.Uint64b5.FBESize() +
        0
    return fbeResult
}

// Get the field extra size
func (fm *FieldModelEnums) FBEExtra() int {
    if (fm.buffer.Offset() + fm.FBEOffset() + fm.FBESize()) > fm.buffer.Size() {
        return 0
    }

    fbeStructOffset := int(fbe.ReadUInt32(fm.buffer.Data(), fm.buffer.Offset() + fm.FBEOffset()))
    if (fbeStructOffset == 0) || ((fm.buffer.Offset() + fbeStructOffset + 4) > fm.buffer.Size()) {
        return 0
    }

    fm.buffer.Shift(fbeStructOffset)

    fbeResult := fm.FBEBody() +
        fm.Byte0.FBEExtra() +
        fm.Byte1.FBEExtra() +
        fm.Byte2.FBEExtra() +
        fm.Byte3.FBEExtra() +
        fm.Byte4.FBEExtra() +
        fm.Byte5.FBEExtra() +
        fm.Char0.FBEExtra() +
        fm.Char1.FBEExtra() +
        fm.Char2.FBEExtra() +
        fm.Char3.FBEExtra() +
        fm.Char4.FBEExtra() +
        fm.Char5.FBEExtra() +
        fm.Wchar0.FBEExtra() +
        fm.Wchar1.FBEExtra() +
        fm.Wchar2.FBEExtra() +
        fm.Wchar3.FBEExtra() +
        fm.Wchar4.FBEExtra() +
        fm.Wchar5.FBEExtra() +
        fm.Int8b0.FBEExtra() +
        fm.Int8b1.FBEExtra() +
        fm.Int8b2.FBEExtra() +
        fm.Int8b3.FBEExtra() +
        fm.Int8b4.FBEExtra() +
        fm.Int8b5.FBEExtra() +
        fm.Uint8b0.FBEExtra() +
        fm.Uint8b1.FBEExtra() +
        fm.Uint8b2.FBEExtra() +
        fm.Uint8b3.FBEExtra() +
        fm.Uint8b4.FBEExtra() +
        fm.Uint8b5.FBEExtra() +
        fm.Int16b0.FBEExtra() +
        fm.Int16b1.FBEExtra() +
        fm.Int16b2.FBEExtra() +
        fm.Int16b3.FBEExtra() +
        fm.Int16b4.FBEExtra() +
        fm.Int16b5.FBEExtra() +
        fm.Uint16b0.FBEExtra() +
        fm.Uint16b1.FBEExtra() +
        fm.Uint16b2.FBEExtra() +
        fm.Uint16b3.FBEExtra() +
        fm.Uint16b4.FBEExtra() +
        fm.Uint16b5.FBEExtra() +
        fm.Int32b0.FBEExtra() +
        fm.Int32b1.FBEExtra() +
        fm.Int32b2.FBEExtra() +
        fm.Int32b3.FBEExtra() +
        fm.Int32b4.FBEExtra() +
        fm.Int32b5.FBEExtra() +
        fm.Uint32b0.FBEExtra() +
        fm.Uint32b1.FBEExtra() +
        fm.Uint32b2.FBEExtra() +
        fm.Uint32b3.FBEExtra() +
        fm.Uint32b4.FBEExtra() +
        fm.Uint32b5.FBEExtra() +
        fm.Int64b0.FBEExtra() +
        fm.Int64b1.FBEExtra() +
        fm.Int64b2.FBEExtra() +
        fm.Int64b3.FBEExtra() +
        fm.Int64b4.FBEExtra() +
        fm.Int64b5.FBEExtra() +
        fm.Uint64b0.FBEExtra() +
        fm.Uint64b1.FBEExtra() +
        fm.Uint64b2.FBEExtra() +
        fm.Uint64b3.FBEExtra() +
        fm.Uint64b4.FBEExtra() +
        fm.Uint64b5.FBEExtra() +
        0

    fm.buffer.Unshift(fbeStructOffset)

    return fbeResult
}

// Get the field type
func (fm *FieldModelEnums) FBEType() int { return 1 }

// Get the field offset
func (fm *FieldModelEnums) FBEOffset() int { return fm.offset }
// Set the field offset
func (fm *FieldModelEnums) SetFBEOffset(value int) { fm.offset = value }

// Shift the current field offset
func (fm *FieldModelEnums) FBEShift(size int) { fm.offset += size }
// Unshift the current field offset
func (fm *FieldModelEnums) FBEUnshift(size int) { fm.offset -= size }

// Check if the struct value is valid
func (fm *FieldModelEnums) Verify() bool { return fm.VerifyType(true) }

// Check if the struct value and its type are valid
func (fm *FieldModelEnums) VerifyType(fbeVerifyType bool) bool {
    if (fm.buffer.Offset() + fm.FBEOffset() + fm.FBESize()) > fm.buffer.Size() {
        return true
    }

    fbeStructOffset := int(fbe.ReadUInt32(fm.buffer.Data(), fm.buffer.Offset() + fm.FBEOffset()))
    if (fbeStructOffset == 0) || ((fm.buffer.Offset() + fbeStructOffset + 4 + 4) > fm.buffer.Size()) {
        return false
    }

    fbeStructSize := int(fbe.ReadUInt32(fm.buffer.Data(), fm.buffer.Offset() + fbeStructOffset))
    if fbeStructSize < (4 + 4) {
        return false
    }

    fbeStructType := int(fbe.ReadUInt32(fm.buffer.Data(), fm.buffer.Offset() + fbeStructOffset + 4))
    if fbeVerifyType && (fbeStructType != fm.FBEType()) {
        return false
    }

    fm.buffer.Shift(fbeStructOffset)
    fbeResult := fm.VerifyFields(fbeStructSize)
    fm.buffer.Unshift(fbeStructOffset)
    return fbeResult
}

// // Check if the struct value fields are valid
func (fm *FieldModelEnums) VerifyFields(fbeStructSize int) bool {
    fbeCurrentSize := 4 + 4

    if (fbeCurrentSize + fm.Byte0.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Byte0.Verify() {
        return false
    }
    fbeCurrentSize += fm.Byte0.FBESize()

    if (fbeCurrentSize + fm.Byte1.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Byte1.Verify() {
        return false
    }
    fbeCurrentSize += fm.Byte1.FBESize()

    if (fbeCurrentSize + fm.Byte2.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Byte2.Verify() {
        return false
    }
    fbeCurrentSize += fm.Byte2.FBESize()

    if (fbeCurrentSize + fm.Byte3.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Byte3.Verify() {
        return false
    }
    fbeCurrentSize += fm.Byte3.FBESize()

    if (fbeCurrentSize + fm.Byte4.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Byte4.Verify() {
        return false
    }
    fbeCurrentSize += fm.Byte4.FBESize()

    if (fbeCurrentSize + fm.Byte5.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Byte5.Verify() {
        return false
    }
    fbeCurrentSize += fm.Byte5.FBESize()

    if (fbeCurrentSize + fm.Char0.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Char0.Verify() {
        return false
    }
    fbeCurrentSize += fm.Char0.FBESize()

    if (fbeCurrentSize + fm.Char1.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Char1.Verify() {
        return false
    }
    fbeCurrentSize += fm.Char1.FBESize()

    if (fbeCurrentSize + fm.Char2.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Char2.Verify() {
        return false
    }
    fbeCurrentSize += fm.Char2.FBESize()

    if (fbeCurrentSize + fm.Char3.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Char3.Verify() {
        return false
    }
    fbeCurrentSize += fm.Char3.FBESize()

    if (fbeCurrentSize + fm.Char4.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Char4.Verify() {
        return false
    }
    fbeCurrentSize += fm.Char4.FBESize()

    if (fbeCurrentSize + fm.Char5.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Char5.Verify() {
        return false
    }
    fbeCurrentSize += fm.Char5.FBESize()

    if (fbeCurrentSize + fm.Wchar0.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Wchar0.Verify() {
        return false
    }
    fbeCurrentSize += fm.Wchar0.FBESize()

    if (fbeCurrentSize + fm.Wchar1.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Wchar1.Verify() {
        return false
    }
    fbeCurrentSize += fm.Wchar1.FBESize()

    if (fbeCurrentSize + fm.Wchar2.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Wchar2.Verify() {
        return false
    }
    fbeCurrentSize += fm.Wchar2.FBESize()

    if (fbeCurrentSize + fm.Wchar3.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Wchar3.Verify() {
        return false
    }
    fbeCurrentSize += fm.Wchar3.FBESize()

    if (fbeCurrentSize + fm.Wchar4.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Wchar4.Verify() {
        return false
    }
    fbeCurrentSize += fm.Wchar4.FBESize()

    if (fbeCurrentSize + fm.Wchar5.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Wchar5.Verify() {
        return false
    }
    fbeCurrentSize += fm.Wchar5.FBESize()

    if (fbeCurrentSize + fm.Int8b0.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Int8b0.Verify() {
        return false
    }
    fbeCurrentSize += fm.Int8b0.FBESize()

    if (fbeCurrentSize + fm.Int8b1.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Int8b1.Verify() {
        return false
    }
    fbeCurrentSize += fm.Int8b1.FBESize()

    if (fbeCurrentSize + fm.Int8b2.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Int8b2.Verify() {
        return false
    }
    fbeCurrentSize += fm.Int8b2.FBESize()

    if (fbeCurrentSize + fm.Int8b3.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Int8b3.Verify() {
        return false
    }
    fbeCurrentSize += fm.Int8b3.FBESize()

    if (fbeCurrentSize + fm.Int8b4.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Int8b4.Verify() {
        return false
    }
    fbeCurrentSize += fm.Int8b4.FBESize()

    if (fbeCurrentSize + fm.Int8b5.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Int8b5.Verify() {
        return false
    }
    fbeCurrentSize += fm.Int8b5.FBESize()

    if (fbeCurrentSize + fm.Uint8b0.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Uint8b0.Verify() {
        return false
    }
    fbeCurrentSize += fm.Uint8b0.FBESize()

    if (fbeCurrentSize + fm.Uint8b1.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Uint8b1.Verify() {
        return false
    }
    fbeCurrentSize += fm.Uint8b1.FBESize()

    if (fbeCurrentSize + fm.Uint8b2.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Uint8b2.Verify() {
        return false
    }
    fbeCurrentSize += fm.Uint8b2.FBESize()

    if (fbeCurrentSize + fm.Uint8b3.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Uint8b3.Verify() {
        return false
    }
    fbeCurrentSize += fm.Uint8b3.FBESize()

    if (fbeCurrentSize + fm.Uint8b4.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Uint8b4.Verify() {
        return false
    }
    fbeCurrentSize += fm.Uint8b4.FBESize()

    if (fbeCurrentSize + fm.Uint8b5.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Uint8b5.Verify() {
        return false
    }
    fbeCurrentSize += fm.Uint8b5.FBESize()

    if (fbeCurrentSize + fm.Int16b0.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Int16b0.Verify() {
        return false
    }
    fbeCurrentSize += fm.Int16b0.FBESize()

    if (fbeCurrentSize + fm.Int16b1.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Int16b1.Verify() {
        return false
    }
    fbeCurrentSize += fm.Int16b1.FBESize()

    if (fbeCurrentSize + fm.Int16b2.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Int16b2.Verify() {
        return false
    }
    fbeCurrentSize += fm.Int16b2.FBESize()

    if (fbeCurrentSize + fm.Int16b3.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Int16b3.Verify() {
        return false
    }
    fbeCurrentSize += fm.Int16b3.FBESize()

    if (fbeCurrentSize + fm.Int16b4.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Int16b4.Verify() {
        return false
    }
    fbeCurrentSize += fm.Int16b4.FBESize()

    if (fbeCurrentSize + fm.Int16b5.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Int16b5.Verify() {
        return false
    }
    fbeCurrentSize += fm.Int16b5.FBESize()

    if (fbeCurrentSize + fm.Uint16b0.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Uint16b0.Verify() {
        return false
    }
    fbeCurrentSize += fm.Uint16b0.FBESize()

    if (fbeCurrentSize + fm.Uint16b1.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Uint16b1.Verify() {
        return false
    }
    fbeCurrentSize += fm.Uint16b1.FBESize()

    if (fbeCurrentSize + fm.Uint16b2.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Uint16b2.Verify() {
        return false
    }
    fbeCurrentSize += fm.Uint16b2.FBESize()

    if (fbeCurrentSize + fm.Uint16b3.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Uint16b3.Verify() {
        return false
    }
    fbeCurrentSize += fm.Uint16b3.FBESize()

    if (fbeCurrentSize + fm.Uint16b4.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Uint16b4.Verify() {
        return false
    }
    fbeCurrentSize += fm.Uint16b4.FBESize()

    if (fbeCurrentSize + fm.Uint16b5.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Uint16b5.Verify() {
        return false
    }
    fbeCurrentSize += fm.Uint16b5.FBESize()

    if (fbeCurrentSize + fm.Int32b0.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Int32b0.Verify() {
        return false
    }
    fbeCurrentSize += fm.Int32b0.FBESize()

    if (fbeCurrentSize + fm.Int32b1.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Int32b1.Verify() {
        return false
    }
    fbeCurrentSize += fm.Int32b1.FBESize()

    if (fbeCurrentSize + fm.Int32b2.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Int32b2.Verify() {
        return false
    }
    fbeCurrentSize += fm.Int32b2.FBESize()

    if (fbeCurrentSize + fm.Int32b3.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Int32b3.Verify() {
        return false
    }
    fbeCurrentSize += fm.Int32b3.FBESize()

    if (fbeCurrentSize + fm.Int32b4.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Int32b4.Verify() {
        return false
    }
    fbeCurrentSize += fm.Int32b4.FBESize()

    if (fbeCurrentSize + fm.Int32b5.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Int32b5.Verify() {
        return false
    }
    fbeCurrentSize += fm.Int32b5.FBESize()

    if (fbeCurrentSize + fm.Uint32b0.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Uint32b0.Verify() {
        return false
    }
    fbeCurrentSize += fm.Uint32b0.FBESize()

    if (fbeCurrentSize + fm.Uint32b1.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Uint32b1.Verify() {
        return false
    }
    fbeCurrentSize += fm.Uint32b1.FBESize()

    if (fbeCurrentSize + fm.Uint32b2.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Uint32b2.Verify() {
        return false
    }
    fbeCurrentSize += fm.Uint32b2.FBESize()

    if (fbeCurrentSize + fm.Uint32b3.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Uint32b3.Verify() {
        return false
    }
    fbeCurrentSize += fm.Uint32b3.FBESize()

    if (fbeCurrentSize + fm.Uint32b4.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Uint32b4.Verify() {
        return false
    }
    fbeCurrentSize += fm.Uint32b4.FBESize()

    if (fbeCurrentSize + fm.Uint32b5.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Uint32b5.Verify() {
        return false
    }
    fbeCurrentSize += fm.Uint32b5.FBESize()

    if (fbeCurrentSize + fm.Int64b0.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Int64b0.Verify() {
        return false
    }
    fbeCurrentSize += fm.Int64b0.FBESize()

    if (fbeCurrentSize + fm.Int64b1.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Int64b1.Verify() {
        return false
    }
    fbeCurrentSize += fm.Int64b1.FBESize()

    if (fbeCurrentSize + fm.Int64b2.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Int64b2.Verify() {
        return false
    }
    fbeCurrentSize += fm.Int64b2.FBESize()

    if (fbeCurrentSize + fm.Int64b3.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Int64b3.Verify() {
        return false
    }
    fbeCurrentSize += fm.Int64b3.FBESize()

    if (fbeCurrentSize + fm.Int64b4.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Int64b4.Verify() {
        return false
    }
    fbeCurrentSize += fm.Int64b4.FBESize()

    if (fbeCurrentSize + fm.Int64b5.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Int64b5.Verify() {
        return false
    }
    fbeCurrentSize += fm.Int64b5.FBESize()

    if (fbeCurrentSize + fm.Uint64b0.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Uint64b0.Verify() {
        return false
    }
    fbeCurrentSize += fm.Uint64b0.FBESize()

    if (fbeCurrentSize + fm.Uint64b1.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Uint64b1.Verify() {
        return false
    }
    fbeCurrentSize += fm.Uint64b1.FBESize()

    if (fbeCurrentSize + fm.Uint64b2.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Uint64b2.Verify() {
        return false
    }
    fbeCurrentSize += fm.Uint64b2.FBESize()

    if (fbeCurrentSize + fm.Uint64b3.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Uint64b3.Verify() {
        return false
    }
    fbeCurrentSize += fm.Uint64b3.FBESize()

    if (fbeCurrentSize + fm.Uint64b4.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Uint64b4.Verify() {
        return false
    }
    fbeCurrentSize += fm.Uint64b4.FBESize()

    if (fbeCurrentSize + fm.Uint64b5.FBESize()) > fbeStructSize {
        return true
    }
    if !fm.Uint64b5.Verify() {
        return false
    }
    fbeCurrentSize += fm.Uint64b5.FBESize()

    return true
}

// Get the struct value (begin phase)
func (fm *FieldModelEnums) GetBegin() (int, error) {
    if (fm.buffer.Offset() + fm.FBEOffset() + fm.FBESize()) > fm.buffer.Size() {
        return 0, nil
    }

    fbeStructOffset := int(fbe.ReadUInt32(fm.buffer.Data(), fm.buffer.Offset() + fm.FBEOffset()))
    if (fbeStructOffset == 0) || ((fm.buffer.Offset() + fbeStructOffset + 4 + 4) > fm.buffer.Size()) {
        return 0, errors.New("model is broken")
    }

    fbeStructSize := int(fbe.ReadUInt32(fm.buffer.Data(), fm.buffer.Offset() + fbeStructOffset))
    if fbeStructSize < (4 + 4) {
        return 0, errors.New("model is broken")
    }

    fm.buffer.Shift(fbeStructOffset)
    return fbeStructOffset, nil
}

// Get the struct value (end phase)
func (fm *FieldModelEnums) GetEnd(fbeBegin int) {
    fm.buffer.Unshift(fbeBegin)
}

// Get the struct value
func (fm *FieldModelEnums) Get() (*Enums, error) {
    fbeResult := NewEnums()
    return fbeResult, fm.GetValue(fbeResult)
}

// Get the struct value by the given pointer
func (fm *FieldModelEnums) GetValue(fbeValue *Enums) error {
    fbeBegin, err := fm.GetBegin()
    if fbeBegin == 0 {
        return err
    }

    fbeStructSize := int(fbe.ReadUInt32(fm.buffer.Data(), fm.buffer.Offset()))
    fm.GetFields(fbeValue, fbeStructSize)
    fm.GetEnd(fbeBegin)
    return nil
}

// Get the struct fields values
func (fm *FieldModelEnums) GetFields(fbeValue *Enums, fbeStructSize int) {
    fbeCurrentSize := 4 + 4

    if (fbeCurrentSize + fm.Byte0.FBESize()) <= fbeStructSize {
        _ = fm.Byte0.GetValueDefault(&fbeValue.Byte0, EnumByte_ENUM_VALUE_0)
    } else {
        fbeValue.Byte0 = EnumByte_ENUM_VALUE_0
    }
    fbeCurrentSize += fm.Byte0.FBESize()

    if (fbeCurrentSize + fm.Byte1.FBESize()) <= fbeStructSize {
        _ = fm.Byte1.GetValueDefault(&fbeValue.Byte1, EnumByte_ENUM_VALUE_1)
    } else {
        fbeValue.Byte1 = EnumByte_ENUM_VALUE_1
    }
    fbeCurrentSize += fm.Byte1.FBESize()

    if (fbeCurrentSize + fm.Byte2.FBESize()) <= fbeStructSize {
        _ = fm.Byte2.GetValueDefault(&fbeValue.Byte2, EnumByte_ENUM_VALUE_2)
    } else {
        fbeValue.Byte2 = EnumByte_ENUM_VALUE_2
    }
    fbeCurrentSize += fm.Byte2.FBESize()

    if (fbeCurrentSize + fm.Byte3.FBESize()) <= fbeStructSize {
        _ = fm.Byte3.GetValueDefault(&fbeValue.Byte3, EnumByte_ENUM_VALUE_3)
    } else {
        fbeValue.Byte3 = EnumByte_ENUM_VALUE_3
    }
    fbeCurrentSize += fm.Byte3.FBESize()

    if (fbeCurrentSize + fm.Byte4.FBESize()) <= fbeStructSize {
        _ = fm.Byte4.GetValueDefault(&fbeValue.Byte4, EnumByte_ENUM_VALUE_4)
    } else {
        fbeValue.Byte4 = EnumByte_ENUM_VALUE_4
    }
    fbeCurrentSize += fm.Byte4.FBESize()

    if (fbeCurrentSize + fm.Byte5.FBESize()) <= fbeStructSize {
        _ = fm.Byte5.GetValueDefault(&fbeValue.Byte5, EnumByte_ENUM_VALUE_5)
    } else {
        fbeValue.Byte5 = EnumByte_ENUM_VALUE_5
    }
    fbeCurrentSize += fm.Byte5.FBESize()

    if (fbeCurrentSize + fm.Char0.FBESize()) <= fbeStructSize {
        _ = fm.Char0.GetValueDefault(&fbeValue.Char0, EnumChar_ENUM_VALUE_0)
    } else {
        fbeValue.Char0 = EnumChar_ENUM_VALUE_0
    }
    fbeCurrentSize += fm.Char0.FBESize()

    if (fbeCurrentSize + fm.Char1.FBESize()) <= fbeStructSize {
        _ = fm.Char1.GetValueDefault(&fbeValue.Char1, EnumChar_ENUM_VALUE_1)
    } else {
        fbeValue.Char1 = EnumChar_ENUM_VALUE_1
    }
    fbeCurrentSize += fm.Char1.FBESize()

    if (fbeCurrentSize + fm.Char2.FBESize()) <= fbeStructSize {
        _ = fm.Char2.GetValueDefault(&fbeValue.Char2, EnumChar_ENUM_VALUE_2)
    } else {
        fbeValue.Char2 = EnumChar_ENUM_VALUE_2
    }
    fbeCurrentSize += fm.Char2.FBESize()

    if (fbeCurrentSize + fm.Char3.FBESize()) <= fbeStructSize {
        _ = fm.Char3.GetValueDefault(&fbeValue.Char3, EnumChar_ENUM_VALUE_3)
    } else {
        fbeValue.Char3 = EnumChar_ENUM_VALUE_3
    }
    fbeCurrentSize += fm.Char3.FBESize()

    if (fbeCurrentSize + fm.Char4.FBESize()) <= fbeStructSize {
        _ = fm.Char4.GetValueDefault(&fbeValue.Char4, EnumChar_ENUM_VALUE_4)
    } else {
        fbeValue.Char4 = EnumChar_ENUM_VALUE_4
    }
    fbeCurrentSize += fm.Char4.FBESize()

    if (fbeCurrentSize + fm.Char5.FBESize()) <= fbeStructSize {
        _ = fm.Char5.GetValueDefault(&fbeValue.Char5, EnumChar_ENUM_VALUE_5)
    } else {
        fbeValue.Char5 = EnumChar_ENUM_VALUE_5
    }
    fbeCurrentSize += fm.Char5.FBESize()

    if (fbeCurrentSize + fm.Wchar0.FBESize()) <= fbeStructSize {
        _ = fm.Wchar0.GetValueDefault(&fbeValue.Wchar0, EnumWChar_ENUM_VALUE_0)
    } else {
        fbeValue.Wchar0 = EnumWChar_ENUM_VALUE_0
    }
    fbeCurrentSize += fm.Wchar0.FBESize()

    if (fbeCurrentSize + fm.Wchar1.FBESize()) <= fbeStructSize {
        _ = fm.Wchar1.GetValueDefault(&fbeValue.Wchar1, EnumWChar_ENUM_VALUE_1)
    } else {
        fbeValue.Wchar1 = EnumWChar_ENUM_VALUE_1
    }
    fbeCurrentSize += fm.Wchar1.FBESize()

    if (fbeCurrentSize + fm.Wchar2.FBESize()) <= fbeStructSize {
        _ = fm.Wchar2.GetValueDefault(&fbeValue.Wchar2, EnumWChar_ENUM_VALUE_2)
    } else {
        fbeValue.Wchar2 = EnumWChar_ENUM_VALUE_2
    }
    fbeCurrentSize += fm.Wchar2.FBESize()

    if (fbeCurrentSize + fm.Wchar3.FBESize()) <= fbeStructSize {
        _ = fm.Wchar3.GetValueDefault(&fbeValue.Wchar3, EnumWChar_ENUM_VALUE_3)
    } else {
        fbeValue.Wchar3 = EnumWChar_ENUM_VALUE_3
    }
    fbeCurrentSize += fm.Wchar3.FBESize()

    if (fbeCurrentSize + fm.Wchar4.FBESize()) <= fbeStructSize {
        _ = fm.Wchar4.GetValueDefault(&fbeValue.Wchar4, EnumWChar_ENUM_VALUE_4)
    } else {
        fbeValue.Wchar4 = EnumWChar_ENUM_VALUE_4
    }
    fbeCurrentSize += fm.Wchar4.FBESize()

    if (fbeCurrentSize + fm.Wchar5.FBESize()) <= fbeStructSize {
        _ = fm.Wchar5.GetValueDefault(&fbeValue.Wchar5, EnumWChar_ENUM_VALUE_5)
    } else {
        fbeValue.Wchar5 = EnumWChar_ENUM_VALUE_5
    }
    fbeCurrentSize += fm.Wchar5.FBESize()

    if (fbeCurrentSize + fm.Int8b0.FBESize()) <= fbeStructSize {
        _ = fm.Int8b0.GetValueDefault(&fbeValue.Int8b0, EnumInt8_ENUM_VALUE_0)
    } else {
        fbeValue.Int8b0 = EnumInt8_ENUM_VALUE_0
    }
    fbeCurrentSize += fm.Int8b0.FBESize()

    if (fbeCurrentSize + fm.Int8b1.FBESize()) <= fbeStructSize {
        _ = fm.Int8b1.GetValueDefault(&fbeValue.Int8b1, EnumInt8_ENUM_VALUE_1)
    } else {
        fbeValue.Int8b1 = EnumInt8_ENUM_VALUE_1
    }
    fbeCurrentSize += fm.Int8b1.FBESize()

    if (fbeCurrentSize + fm.Int8b2.FBESize()) <= fbeStructSize {
        _ = fm.Int8b2.GetValueDefault(&fbeValue.Int8b2, EnumInt8_ENUM_VALUE_2)
    } else {
        fbeValue.Int8b2 = EnumInt8_ENUM_VALUE_2
    }
    fbeCurrentSize += fm.Int8b2.FBESize()

    if (fbeCurrentSize + fm.Int8b3.FBESize()) <= fbeStructSize {
        _ = fm.Int8b3.GetValueDefault(&fbeValue.Int8b3, EnumInt8_ENUM_VALUE_3)
    } else {
        fbeValue.Int8b3 = EnumInt8_ENUM_VALUE_3
    }
    fbeCurrentSize += fm.Int8b3.FBESize()

    if (fbeCurrentSize + fm.Int8b4.FBESize()) <= fbeStructSize {
        _ = fm.Int8b4.GetValueDefault(&fbeValue.Int8b4, EnumInt8_ENUM_VALUE_4)
    } else {
        fbeValue.Int8b4 = EnumInt8_ENUM_VALUE_4
    }
    fbeCurrentSize += fm.Int8b4.FBESize()

    if (fbeCurrentSize + fm.Int8b5.FBESize()) <= fbeStructSize {
        _ = fm.Int8b5.GetValueDefault(&fbeValue.Int8b5, EnumInt8_ENUM_VALUE_5)
    } else {
        fbeValue.Int8b5 = EnumInt8_ENUM_VALUE_5
    }
    fbeCurrentSize += fm.Int8b5.FBESize()

    if (fbeCurrentSize + fm.Uint8b0.FBESize()) <= fbeStructSize {
        _ = fm.Uint8b0.GetValueDefault(&fbeValue.Uint8b0, EnumUInt8_ENUM_VALUE_0)
    } else {
        fbeValue.Uint8b0 = EnumUInt8_ENUM_VALUE_0
    }
    fbeCurrentSize += fm.Uint8b0.FBESize()

    if (fbeCurrentSize + fm.Uint8b1.FBESize()) <= fbeStructSize {
        _ = fm.Uint8b1.GetValueDefault(&fbeValue.Uint8b1, EnumUInt8_ENUM_VALUE_1)
    } else {
        fbeValue.Uint8b1 = EnumUInt8_ENUM_VALUE_1
    }
    fbeCurrentSize += fm.Uint8b1.FBESize()

    if (fbeCurrentSize + fm.Uint8b2.FBESize()) <= fbeStructSize {
        _ = fm.Uint8b2.GetValueDefault(&fbeValue.Uint8b2, EnumUInt8_ENUM_VALUE_2)
    } else {
        fbeValue.Uint8b2 = EnumUInt8_ENUM_VALUE_2
    }
    fbeCurrentSize += fm.Uint8b2.FBESize()

    if (fbeCurrentSize + fm.Uint8b3.FBESize()) <= fbeStructSize {
        _ = fm.Uint8b3.GetValueDefault(&fbeValue.Uint8b3, EnumUInt8_ENUM_VALUE_3)
    } else {
        fbeValue.Uint8b3 = EnumUInt8_ENUM_VALUE_3
    }
    fbeCurrentSize += fm.Uint8b3.FBESize()

    if (fbeCurrentSize + fm.Uint8b4.FBESize()) <= fbeStructSize {
        _ = fm.Uint8b4.GetValueDefault(&fbeValue.Uint8b4, EnumUInt8_ENUM_VALUE_4)
    } else {
        fbeValue.Uint8b4 = EnumUInt8_ENUM_VALUE_4
    }
    fbeCurrentSize += fm.Uint8b4.FBESize()

    if (fbeCurrentSize + fm.Uint8b5.FBESize()) <= fbeStructSize {
        _ = fm.Uint8b5.GetValueDefault(&fbeValue.Uint8b5, EnumUInt8_ENUM_VALUE_5)
    } else {
        fbeValue.Uint8b5 = EnumUInt8_ENUM_VALUE_5
    }
    fbeCurrentSize += fm.Uint8b5.FBESize()

    if (fbeCurrentSize + fm.Int16b0.FBESize()) <= fbeStructSize {
        _ = fm.Int16b0.GetValueDefault(&fbeValue.Int16b0, EnumInt16_ENUM_VALUE_0)
    } else {
        fbeValue.Int16b0 = EnumInt16_ENUM_VALUE_0
    }
    fbeCurrentSize += fm.Int16b0.FBESize()

    if (fbeCurrentSize + fm.Int16b1.FBESize()) <= fbeStructSize {
        _ = fm.Int16b1.GetValueDefault(&fbeValue.Int16b1, EnumInt16_ENUM_VALUE_1)
    } else {
        fbeValue.Int16b1 = EnumInt16_ENUM_VALUE_1
    }
    fbeCurrentSize += fm.Int16b1.FBESize()

    if (fbeCurrentSize + fm.Int16b2.FBESize()) <= fbeStructSize {
        _ = fm.Int16b2.GetValueDefault(&fbeValue.Int16b2, EnumInt16_ENUM_VALUE_2)
    } else {
        fbeValue.Int16b2 = EnumInt16_ENUM_VALUE_2
    }
    fbeCurrentSize += fm.Int16b2.FBESize()

    if (fbeCurrentSize + fm.Int16b3.FBESize()) <= fbeStructSize {
        _ = fm.Int16b3.GetValueDefault(&fbeValue.Int16b3, EnumInt16_ENUM_VALUE_3)
    } else {
        fbeValue.Int16b3 = EnumInt16_ENUM_VALUE_3
    }
    fbeCurrentSize += fm.Int16b3.FBESize()

    if (fbeCurrentSize + fm.Int16b4.FBESize()) <= fbeStructSize {
        _ = fm.Int16b4.GetValueDefault(&fbeValue.Int16b4, EnumInt16_ENUM_VALUE_4)
    } else {
        fbeValue.Int16b4 = EnumInt16_ENUM_VALUE_4
    }
    fbeCurrentSize += fm.Int16b4.FBESize()

    if (fbeCurrentSize + fm.Int16b5.FBESize()) <= fbeStructSize {
        _ = fm.Int16b5.GetValueDefault(&fbeValue.Int16b5, EnumInt16_ENUM_VALUE_5)
    } else {
        fbeValue.Int16b5 = EnumInt16_ENUM_VALUE_5
    }
    fbeCurrentSize += fm.Int16b5.FBESize()

    if (fbeCurrentSize + fm.Uint16b0.FBESize()) <= fbeStructSize {
        _ = fm.Uint16b0.GetValueDefault(&fbeValue.Uint16b0, EnumUInt16_ENUM_VALUE_0)
    } else {
        fbeValue.Uint16b0 = EnumUInt16_ENUM_VALUE_0
    }
    fbeCurrentSize += fm.Uint16b0.FBESize()

    if (fbeCurrentSize + fm.Uint16b1.FBESize()) <= fbeStructSize {
        _ = fm.Uint16b1.GetValueDefault(&fbeValue.Uint16b1, EnumUInt16_ENUM_VALUE_1)
    } else {
        fbeValue.Uint16b1 = EnumUInt16_ENUM_VALUE_1
    }
    fbeCurrentSize += fm.Uint16b1.FBESize()

    if (fbeCurrentSize + fm.Uint16b2.FBESize()) <= fbeStructSize {
        _ = fm.Uint16b2.GetValueDefault(&fbeValue.Uint16b2, EnumUInt16_ENUM_VALUE_2)
    } else {
        fbeValue.Uint16b2 = EnumUInt16_ENUM_VALUE_2
    }
    fbeCurrentSize += fm.Uint16b2.FBESize()

    if (fbeCurrentSize + fm.Uint16b3.FBESize()) <= fbeStructSize {
        _ = fm.Uint16b3.GetValueDefault(&fbeValue.Uint16b3, EnumUInt16_ENUM_VALUE_3)
    } else {
        fbeValue.Uint16b3 = EnumUInt16_ENUM_VALUE_3
    }
    fbeCurrentSize += fm.Uint16b3.FBESize()

    if (fbeCurrentSize + fm.Uint16b4.FBESize()) <= fbeStructSize {
        _ = fm.Uint16b4.GetValueDefault(&fbeValue.Uint16b4, EnumUInt16_ENUM_VALUE_4)
    } else {
        fbeValue.Uint16b4 = EnumUInt16_ENUM_VALUE_4
    }
    fbeCurrentSize += fm.Uint16b4.FBESize()

    if (fbeCurrentSize + fm.Uint16b5.FBESize()) <= fbeStructSize {
        _ = fm.Uint16b5.GetValueDefault(&fbeValue.Uint16b5, EnumUInt16_ENUM_VALUE_5)
    } else {
        fbeValue.Uint16b5 = EnumUInt16_ENUM_VALUE_5
    }
    fbeCurrentSize += fm.Uint16b5.FBESize()

    if (fbeCurrentSize + fm.Int32b0.FBESize()) <= fbeStructSize {
        _ = fm.Int32b0.GetValueDefault(&fbeValue.Int32b0, EnumInt32_ENUM_VALUE_0)
    } else {
        fbeValue.Int32b0 = EnumInt32_ENUM_VALUE_0
    }
    fbeCurrentSize += fm.Int32b0.FBESize()

    if (fbeCurrentSize + fm.Int32b1.FBESize()) <= fbeStructSize {
        _ = fm.Int32b1.GetValueDefault(&fbeValue.Int32b1, EnumInt32_ENUM_VALUE_1)
    } else {
        fbeValue.Int32b1 = EnumInt32_ENUM_VALUE_1
    }
    fbeCurrentSize += fm.Int32b1.FBESize()

    if (fbeCurrentSize + fm.Int32b2.FBESize()) <= fbeStructSize {
        _ = fm.Int32b2.GetValueDefault(&fbeValue.Int32b2, EnumInt32_ENUM_VALUE_2)
    } else {
        fbeValue.Int32b2 = EnumInt32_ENUM_VALUE_2
    }
    fbeCurrentSize += fm.Int32b2.FBESize()

    if (fbeCurrentSize + fm.Int32b3.FBESize()) <= fbeStructSize {
        _ = fm.Int32b3.GetValueDefault(&fbeValue.Int32b3, EnumInt32_ENUM_VALUE_3)
    } else {
        fbeValue.Int32b3 = EnumInt32_ENUM_VALUE_3
    }
    fbeCurrentSize += fm.Int32b3.FBESize()

    if (fbeCurrentSize + fm.Int32b4.FBESize()) <= fbeStructSize {
        _ = fm.Int32b4.GetValueDefault(&fbeValue.Int32b4, EnumInt32_ENUM_VALUE_4)
    } else {
        fbeValue.Int32b4 = EnumInt32_ENUM_VALUE_4
    }
    fbeCurrentSize += fm.Int32b4.FBESize()

    if (fbeCurrentSize + fm.Int32b5.FBESize()) <= fbeStructSize {
        _ = fm.Int32b5.GetValueDefault(&fbeValue.Int32b5, EnumInt32_ENUM_VALUE_5)
    } else {
        fbeValue.Int32b5 = EnumInt32_ENUM_VALUE_5
    }
    fbeCurrentSize += fm.Int32b5.FBESize()

    if (fbeCurrentSize + fm.Uint32b0.FBESize()) <= fbeStructSize {
        _ = fm.Uint32b0.GetValueDefault(&fbeValue.Uint32b0, EnumUInt32_ENUM_VALUE_0)
    } else {
        fbeValue.Uint32b0 = EnumUInt32_ENUM_VALUE_0
    }
    fbeCurrentSize += fm.Uint32b0.FBESize()

    if (fbeCurrentSize + fm.Uint32b1.FBESize()) <= fbeStructSize {
        _ = fm.Uint32b1.GetValueDefault(&fbeValue.Uint32b1, EnumUInt32_ENUM_VALUE_1)
    } else {
        fbeValue.Uint32b1 = EnumUInt32_ENUM_VALUE_1
    }
    fbeCurrentSize += fm.Uint32b1.FBESize()

    if (fbeCurrentSize + fm.Uint32b2.FBESize()) <= fbeStructSize {
        _ = fm.Uint32b2.GetValueDefault(&fbeValue.Uint32b2, EnumUInt32_ENUM_VALUE_2)
    } else {
        fbeValue.Uint32b2 = EnumUInt32_ENUM_VALUE_2
    }
    fbeCurrentSize += fm.Uint32b2.FBESize()

    if (fbeCurrentSize + fm.Uint32b3.FBESize()) <= fbeStructSize {
        _ = fm.Uint32b3.GetValueDefault(&fbeValue.Uint32b3, EnumUInt32_ENUM_VALUE_3)
    } else {
        fbeValue.Uint32b3 = EnumUInt32_ENUM_VALUE_3
    }
    fbeCurrentSize += fm.Uint32b3.FBESize()

    if (fbeCurrentSize + fm.Uint32b4.FBESize()) <= fbeStructSize {
        _ = fm.Uint32b4.GetValueDefault(&fbeValue.Uint32b4, EnumUInt32_ENUM_VALUE_4)
    } else {
        fbeValue.Uint32b4 = EnumUInt32_ENUM_VALUE_4
    }
    fbeCurrentSize += fm.Uint32b4.FBESize()

    if (fbeCurrentSize + fm.Uint32b5.FBESize()) <= fbeStructSize {
        _ = fm.Uint32b5.GetValueDefault(&fbeValue.Uint32b5, EnumUInt32_ENUM_VALUE_5)
    } else {
        fbeValue.Uint32b5 = EnumUInt32_ENUM_VALUE_5
    }
    fbeCurrentSize += fm.Uint32b5.FBESize()

    if (fbeCurrentSize + fm.Int64b0.FBESize()) <= fbeStructSize {
        _ = fm.Int64b0.GetValueDefault(&fbeValue.Int64b0, EnumInt64_ENUM_VALUE_0)
    } else {
        fbeValue.Int64b0 = EnumInt64_ENUM_VALUE_0
    }
    fbeCurrentSize += fm.Int64b0.FBESize()

    if (fbeCurrentSize + fm.Int64b1.FBESize()) <= fbeStructSize {
        _ = fm.Int64b1.GetValueDefault(&fbeValue.Int64b1, EnumInt64_ENUM_VALUE_1)
    } else {
        fbeValue.Int64b1 = EnumInt64_ENUM_VALUE_1
    }
    fbeCurrentSize += fm.Int64b1.FBESize()

    if (fbeCurrentSize + fm.Int64b2.FBESize()) <= fbeStructSize {
        _ = fm.Int64b2.GetValueDefault(&fbeValue.Int64b2, EnumInt64_ENUM_VALUE_2)
    } else {
        fbeValue.Int64b2 = EnumInt64_ENUM_VALUE_2
    }
    fbeCurrentSize += fm.Int64b2.FBESize()

    if (fbeCurrentSize + fm.Int64b3.FBESize()) <= fbeStructSize {
        _ = fm.Int64b3.GetValueDefault(&fbeValue.Int64b3, EnumInt64_ENUM_VALUE_3)
    } else {
        fbeValue.Int64b3 = EnumInt64_ENUM_VALUE_3
    }
    fbeCurrentSize += fm.Int64b3.FBESize()

    if (fbeCurrentSize + fm.Int64b4.FBESize()) <= fbeStructSize {
        _ = fm.Int64b4.GetValueDefault(&fbeValue.Int64b4, EnumInt64_ENUM_VALUE_4)
    } else {
        fbeValue.Int64b4 = EnumInt64_ENUM_VALUE_4
    }
    fbeCurrentSize += fm.Int64b4.FBESize()

    if (fbeCurrentSize + fm.Int64b5.FBESize()) <= fbeStructSize {
        _ = fm.Int64b5.GetValueDefault(&fbeValue.Int64b5, EnumInt64_ENUM_VALUE_5)
    } else {
        fbeValue.Int64b5 = EnumInt64_ENUM_VALUE_5
    }
    fbeCurrentSize += fm.Int64b5.FBESize()

    if (fbeCurrentSize + fm.Uint64b0.FBESize()) <= fbeStructSize {
        _ = fm.Uint64b0.GetValueDefault(&fbeValue.Uint64b0, EnumUInt64_ENUM_VALUE_0)
    } else {
        fbeValue.Uint64b0 = EnumUInt64_ENUM_VALUE_0
    }
    fbeCurrentSize += fm.Uint64b0.FBESize()

    if (fbeCurrentSize + fm.Uint64b1.FBESize()) <= fbeStructSize {
        _ = fm.Uint64b1.GetValueDefault(&fbeValue.Uint64b1, EnumUInt64_ENUM_VALUE_1)
    } else {
        fbeValue.Uint64b1 = EnumUInt64_ENUM_VALUE_1
    }
    fbeCurrentSize += fm.Uint64b1.FBESize()

    if (fbeCurrentSize + fm.Uint64b2.FBESize()) <= fbeStructSize {
        _ = fm.Uint64b2.GetValueDefault(&fbeValue.Uint64b2, EnumUInt64_ENUM_VALUE_2)
    } else {
        fbeValue.Uint64b2 = EnumUInt64_ENUM_VALUE_2
    }
    fbeCurrentSize += fm.Uint64b2.FBESize()

    if (fbeCurrentSize + fm.Uint64b3.FBESize()) <= fbeStructSize {
        _ = fm.Uint64b3.GetValueDefault(&fbeValue.Uint64b3, EnumUInt64_ENUM_VALUE_3)
    } else {
        fbeValue.Uint64b3 = EnumUInt64_ENUM_VALUE_3
    }
    fbeCurrentSize += fm.Uint64b3.FBESize()

    if (fbeCurrentSize + fm.Uint64b4.FBESize()) <= fbeStructSize {
        _ = fm.Uint64b4.GetValueDefault(&fbeValue.Uint64b4, EnumUInt64_ENUM_VALUE_4)
    } else {
        fbeValue.Uint64b4 = EnumUInt64_ENUM_VALUE_4
    }
    fbeCurrentSize += fm.Uint64b4.FBESize()

    if (fbeCurrentSize + fm.Uint64b5.FBESize()) <= fbeStructSize {
        _ = fm.Uint64b5.GetValueDefault(&fbeValue.Uint64b5, EnumUInt64_ENUM_VALUE_5)
    } else {
        fbeValue.Uint64b5 = EnumUInt64_ENUM_VALUE_5
    }
    fbeCurrentSize += fm.Uint64b5.FBESize()
}

// Set the struct value (begin phase)
func (fm *FieldModelEnums) SetBegin() (int, error) {
    if (fm.buffer.Offset() + fm.FBEOffset() + fm.FBESize()) > fm.buffer.Size() {
        return 0, errors.New("model is broken")
    }

    fbeStructSize := fm.FBEBody()
    fbeStructOffset := fm.buffer.Allocate(fbeStructSize) - fm.buffer.Offset()
    if (fbeStructOffset <= 0) || ((fm.buffer.Offset() + fbeStructOffset + fbeStructSize) > fm.buffer.Size()) {
        return 0, errors.New("model is broken")
    }

    fbe.WriteUInt32(fm.buffer.Data(), fm.buffer.Offset() + fm.FBEOffset(), uint32(fbeStructOffset))
    fbe.WriteUInt32(fm.buffer.Data(), fm.buffer.Offset() + fbeStructOffset, uint32(fbeStructSize))
    fbe.WriteUInt32(fm.buffer.Data(), fm.buffer.Offset() + fbeStructOffset + 4, uint32(fm.FBEType()))

    fm.buffer.Shift(fbeStructOffset)
    return fbeStructOffset, nil
}

// Set the struct value (end phase)
func (fm *FieldModelEnums) SetEnd(fbeBegin int) {
    fm.buffer.Unshift(fbeBegin)
}

// Set the struct value
func (fm *FieldModelEnums) Set(fbeValue *Enums) error {
    fbeBegin, err := fm.SetBegin()
    if fbeBegin == 0 {
        return err
    }

    err = fm.SetFields(fbeValue)
    fm.SetEnd(fbeBegin)
    return err
}

// Set the struct fields values
func (fm *FieldModelEnums) SetFields(fbeValue *Enums) error {
    var err error = nil

    if err = fm.Byte0.Set(&fbeValue.Byte0); err != nil {
        return err
    }
    if err = fm.Byte1.Set(&fbeValue.Byte1); err != nil {
        return err
    }
    if err = fm.Byte2.Set(&fbeValue.Byte2); err != nil {
        return err
    }
    if err = fm.Byte3.Set(&fbeValue.Byte3); err != nil {
        return err
    }
    if err = fm.Byte4.Set(&fbeValue.Byte4); err != nil {
        return err
    }
    if err = fm.Byte5.Set(&fbeValue.Byte5); err != nil {
        return err
    }
    if err = fm.Char0.Set(&fbeValue.Char0); err != nil {
        return err
    }
    if err = fm.Char1.Set(&fbeValue.Char1); err != nil {
        return err
    }
    if err = fm.Char2.Set(&fbeValue.Char2); err != nil {
        return err
    }
    if err = fm.Char3.Set(&fbeValue.Char3); err != nil {
        return err
    }
    if err = fm.Char4.Set(&fbeValue.Char4); err != nil {
        return err
    }
    if err = fm.Char5.Set(&fbeValue.Char5); err != nil {
        return err
    }
    if err = fm.Wchar0.Set(&fbeValue.Wchar0); err != nil {
        return err
    }
    if err = fm.Wchar1.Set(&fbeValue.Wchar1); err != nil {
        return err
    }
    if err = fm.Wchar2.Set(&fbeValue.Wchar2); err != nil {
        return err
    }
    if err = fm.Wchar3.Set(&fbeValue.Wchar3); err != nil {
        return err
    }
    if err = fm.Wchar4.Set(&fbeValue.Wchar4); err != nil {
        return err
    }
    if err = fm.Wchar5.Set(&fbeValue.Wchar5); err != nil {
        return err
    }
    if err = fm.Int8b0.Set(&fbeValue.Int8b0); err != nil {
        return err
    }
    if err = fm.Int8b1.Set(&fbeValue.Int8b1); err != nil {
        return err
    }
    if err = fm.Int8b2.Set(&fbeValue.Int8b2); err != nil {
        return err
    }
    if err = fm.Int8b3.Set(&fbeValue.Int8b3); err != nil {
        return err
    }
    if err = fm.Int8b4.Set(&fbeValue.Int8b4); err != nil {
        return err
    }
    if err = fm.Int8b5.Set(&fbeValue.Int8b5); err != nil {
        return err
    }
    if err = fm.Uint8b0.Set(&fbeValue.Uint8b0); err != nil {
        return err
    }
    if err = fm.Uint8b1.Set(&fbeValue.Uint8b1); err != nil {
        return err
    }
    if err = fm.Uint8b2.Set(&fbeValue.Uint8b2); err != nil {
        return err
    }
    if err = fm.Uint8b3.Set(&fbeValue.Uint8b3); err != nil {
        return err
    }
    if err = fm.Uint8b4.Set(&fbeValue.Uint8b4); err != nil {
        return err
    }
    if err = fm.Uint8b5.Set(&fbeValue.Uint8b5); err != nil {
        return err
    }
    if err = fm.Int16b0.Set(&fbeValue.Int16b0); err != nil {
        return err
    }
    if err = fm.Int16b1.Set(&fbeValue.Int16b1); err != nil {
        return err
    }
    if err = fm.Int16b2.Set(&fbeValue.Int16b2); err != nil {
        return err
    }
    if err = fm.Int16b3.Set(&fbeValue.Int16b3); err != nil {
        return err
    }
    if err = fm.Int16b4.Set(&fbeValue.Int16b4); err != nil {
        return err
    }
    if err = fm.Int16b5.Set(&fbeValue.Int16b5); err != nil {
        return err
    }
    if err = fm.Uint16b0.Set(&fbeValue.Uint16b0); err != nil {
        return err
    }
    if err = fm.Uint16b1.Set(&fbeValue.Uint16b1); err != nil {
        return err
    }
    if err = fm.Uint16b2.Set(&fbeValue.Uint16b2); err != nil {
        return err
    }
    if err = fm.Uint16b3.Set(&fbeValue.Uint16b3); err != nil {
        return err
    }
    if err = fm.Uint16b4.Set(&fbeValue.Uint16b4); err != nil {
        return err
    }
    if err = fm.Uint16b5.Set(&fbeValue.Uint16b5); err != nil {
        return err
    }
    if err = fm.Int32b0.Set(&fbeValue.Int32b0); err != nil {
        return err
    }
    if err = fm.Int32b1.Set(&fbeValue.Int32b1); err != nil {
        return err
    }
    if err = fm.Int32b2.Set(&fbeValue.Int32b2); err != nil {
        return err
    }
    if err = fm.Int32b3.Set(&fbeValue.Int32b3); err != nil {
        return err
    }
    if err = fm.Int32b4.Set(&fbeValue.Int32b4); err != nil {
        return err
    }
    if err = fm.Int32b5.Set(&fbeValue.Int32b5); err != nil {
        return err
    }
    if err = fm.Uint32b0.Set(&fbeValue.Uint32b0); err != nil {
        return err
    }
    if err = fm.Uint32b1.Set(&fbeValue.Uint32b1); err != nil {
        return err
    }
    if err = fm.Uint32b2.Set(&fbeValue.Uint32b2); err != nil {
        return err
    }
    if err = fm.Uint32b3.Set(&fbeValue.Uint32b3); err != nil {
        return err
    }
    if err = fm.Uint32b4.Set(&fbeValue.Uint32b4); err != nil {
        return err
    }
    if err = fm.Uint32b5.Set(&fbeValue.Uint32b5); err != nil {
        return err
    }
    if err = fm.Int64b0.Set(&fbeValue.Int64b0); err != nil {
        return err
    }
    if err = fm.Int64b1.Set(&fbeValue.Int64b1); err != nil {
        return err
    }
    if err = fm.Int64b2.Set(&fbeValue.Int64b2); err != nil {
        return err
    }
    if err = fm.Int64b3.Set(&fbeValue.Int64b3); err != nil {
        return err
    }
    if err = fm.Int64b4.Set(&fbeValue.Int64b4); err != nil {
        return err
    }
    if err = fm.Int64b5.Set(&fbeValue.Int64b5); err != nil {
        return err
    }
    if err = fm.Uint64b0.Set(&fbeValue.Uint64b0); err != nil {
        return err
    }
    if err = fm.Uint64b1.Set(&fbeValue.Uint64b1); err != nil {
        return err
    }
    if err = fm.Uint64b2.Set(&fbeValue.Uint64b2); err != nil {
        return err
    }
    if err = fm.Uint64b3.Set(&fbeValue.Uint64b3); err != nil {
        return err
    }
    if err = fm.Uint64b4.Set(&fbeValue.Uint64b4); err != nil {
        return err
    }
    if err = fm.Uint64b5.Set(&fbeValue.Uint64b5); err != nil {
        return err
    }
    return err
}
