//------------------------------------------------------------------------------
// 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 final model
type FinalModelEnums struct {
    buffer *fbe.Buffer  // Final model buffer
    offset int          // Final model buffer offset

    Byte0 *FinalModelEnumByte
    Byte1 *FinalModelEnumByte
    Byte2 *FinalModelEnumByte
    Byte3 *FinalModelEnumByte
    Byte4 *FinalModelEnumByte
    Byte5 *FinalModelEnumByte
    Char0 *FinalModelEnumChar
    Char1 *FinalModelEnumChar
    Char2 *FinalModelEnumChar
    Char3 *FinalModelEnumChar
    Char4 *FinalModelEnumChar
    Char5 *FinalModelEnumChar
    Wchar0 *FinalModelEnumWChar
    Wchar1 *FinalModelEnumWChar
    Wchar2 *FinalModelEnumWChar
    Wchar3 *FinalModelEnumWChar
    Wchar4 *FinalModelEnumWChar
    Wchar5 *FinalModelEnumWChar
    Int8b0 *FinalModelEnumInt8
    Int8b1 *FinalModelEnumInt8
    Int8b2 *FinalModelEnumInt8
    Int8b3 *FinalModelEnumInt8
    Int8b4 *FinalModelEnumInt8
    Int8b5 *FinalModelEnumInt8
    Uint8b0 *FinalModelEnumUInt8
    Uint8b1 *FinalModelEnumUInt8
    Uint8b2 *FinalModelEnumUInt8
    Uint8b3 *FinalModelEnumUInt8
    Uint8b4 *FinalModelEnumUInt8
    Uint8b5 *FinalModelEnumUInt8
    Int16b0 *FinalModelEnumInt16
    Int16b1 *FinalModelEnumInt16
    Int16b2 *FinalModelEnumInt16
    Int16b3 *FinalModelEnumInt16
    Int16b4 *FinalModelEnumInt16
    Int16b5 *FinalModelEnumInt16
    Uint16b0 *FinalModelEnumUInt16
    Uint16b1 *FinalModelEnumUInt16
    Uint16b2 *FinalModelEnumUInt16
    Uint16b3 *FinalModelEnumUInt16
    Uint16b4 *FinalModelEnumUInt16
    Uint16b5 *FinalModelEnumUInt16
    Int32b0 *FinalModelEnumInt32
    Int32b1 *FinalModelEnumInt32
    Int32b2 *FinalModelEnumInt32
    Int32b3 *FinalModelEnumInt32
    Int32b4 *FinalModelEnumInt32
    Int32b5 *FinalModelEnumInt32
    Uint32b0 *FinalModelEnumUInt32
    Uint32b1 *FinalModelEnumUInt32
    Uint32b2 *FinalModelEnumUInt32
    Uint32b3 *FinalModelEnumUInt32
    Uint32b4 *FinalModelEnumUInt32
    Uint32b5 *FinalModelEnumUInt32
    Int64b0 *FinalModelEnumInt64
    Int64b1 *FinalModelEnumInt64
    Int64b2 *FinalModelEnumInt64
    Int64b3 *FinalModelEnumInt64
    Int64b4 *FinalModelEnumInt64
    Int64b5 *FinalModelEnumInt64
    Uint64b0 *FinalModelEnumUInt64
    Uint64b1 *FinalModelEnumUInt64
    Uint64b2 *FinalModelEnumUInt64
    Uint64b3 *FinalModelEnumUInt64
    Uint64b4 *FinalModelEnumUInt64
    Uint64b5 *FinalModelEnumUInt64
}

// Create a new Enums final model
func NewFinalModelEnums(buffer *fbe.Buffer, offset int) *FinalModelEnums {
    fbeResult := FinalModelEnums{buffer: buffer, offset: offset}
    fbeResult.Byte0 = NewFinalModelEnumByte(buffer, 0)
    fbeResult.Byte1 = NewFinalModelEnumByte(buffer, 0)
    fbeResult.Byte2 = NewFinalModelEnumByte(buffer, 0)
    fbeResult.Byte3 = NewFinalModelEnumByte(buffer, 0)
    fbeResult.Byte4 = NewFinalModelEnumByte(buffer, 0)
    fbeResult.Byte5 = NewFinalModelEnumByte(buffer, 0)
    fbeResult.Char0 = NewFinalModelEnumChar(buffer, 0)
    fbeResult.Char1 = NewFinalModelEnumChar(buffer, 0)
    fbeResult.Char2 = NewFinalModelEnumChar(buffer, 0)
    fbeResult.Char3 = NewFinalModelEnumChar(buffer, 0)
    fbeResult.Char4 = NewFinalModelEnumChar(buffer, 0)
    fbeResult.Char5 = NewFinalModelEnumChar(buffer, 0)
    fbeResult.Wchar0 = NewFinalModelEnumWChar(buffer, 0)
    fbeResult.Wchar1 = NewFinalModelEnumWChar(buffer, 0)
    fbeResult.Wchar2 = NewFinalModelEnumWChar(buffer, 0)
    fbeResult.Wchar3 = NewFinalModelEnumWChar(buffer, 0)
    fbeResult.Wchar4 = NewFinalModelEnumWChar(buffer, 0)
    fbeResult.Wchar5 = NewFinalModelEnumWChar(buffer, 0)
    fbeResult.Int8b0 = NewFinalModelEnumInt8(buffer, 0)
    fbeResult.Int8b1 = NewFinalModelEnumInt8(buffer, 0)
    fbeResult.Int8b2 = NewFinalModelEnumInt8(buffer, 0)
    fbeResult.Int8b3 = NewFinalModelEnumInt8(buffer, 0)
    fbeResult.Int8b4 = NewFinalModelEnumInt8(buffer, 0)
    fbeResult.Int8b5 = NewFinalModelEnumInt8(buffer, 0)
    fbeResult.Uint8b0 = NewFinalModelEnumUInt8(buffer, 0)
    fbeResult.Uint8b1 = NewFinalModelEnumUInt8(buffer, 0)
    fbeResult.Uint8b2 = NewFinalModelEnumUInt8(buffer, 0)
    fbeResult.Uint8b3 = NewFinalModelEnumUInt8(buffer, 0)
    fbeResult.Uint8b4 = NewFinalModelEnumUInt8(buffer, 0)
    fbeResult.Uint8b5 = NewFinalModelEnumUInt8(buffer, 0)
    fbeResult.Int16b0 = NewFinalModelEnumInt16(buffer, 0)
    fbeResult.Int16b1 = NewFinalModelEnumInt16(buffer, 0)
    fbeResult.Int16b2 = NewFinalModelEnumInt16(buffer, 0)
    fbeResult.Int16b3 = NewFinalModelEnumInt16(buffer, 0)
    fbeResult.Int16b4 = NewFinalModelEnumInt16(buffer, 0)
    fbeResult.Int16b5 = NewFinalModelEnumInt16(buffer, 0)
    fbeResult.Uint16b0 = NewFinalModelEnumUInt16(buffer, 0)
    fbeResult.Uint16b1 = NewFinalModelEnumUInt16(buffer, 0)
    fbeResult.Uint16b2 = NewFinalModelEnumUInt16(buffer, 0)
    fbeResult.Uint16b3 = NewFinalModelEnumUInt16(buffer, 0)
    fbeResult.Uint16b4 = NewFinalModelEnumUInt16(buffer, 0)
    fbeResult.Uint16b5 = NewFinalModelEnumUInt16(buffer, 0)
    fbeResult.Int32b0 = NewFinalModelEnumInt32(buffer, 0)
    fbeResult.Int32b1 = NewFinalModelEnumInt32(buffer, 0)
    fbeResult.Int32b2 = NewFinalModelEnumInt32(buffer, 0)
    fbeResult.Int32b3 = NewFinalModelEnumInt32(buffer, 0)
    fbeResult.Int32b4 = NewFinalModelEnumInt32(buffer, 0)
    fbeResult.Int32b5 = NewFinalModelEnumInt32(buffer, 0)
    fbeResult.Uint32b0 = NewFinalModelEnumUInt32(buffer, 0)
    fbeResult.Uint32b1 = NewFinalModelEnumUInt32(buffer, 0)
    fbeResult.Uint32b2 = NewFinalModelEnumUInt32(buffer, 0)
    fbeResult.Uint32b3 = NewFinalModelEnumUInt32(buffer, 0)
    fbeResult.Uint32b4 = NewFinalModelEnumUInt32(buffer, 0)
    fbeResult.Uint32b5 = NewFinalModelEnumUInt32(buffer, 0)
    fbeResult.Int64b0 = NewFinalModelEnumInt64(buffer, 0)
    fbeResult.Int64b1 = NewFinalModelEnumInt64(buffer, 0)
    fbeResult.Int64b2 = NewFinalModelEnumInt64(buffer, 0)
    fbeResult.Int64b3 = NewFinalModelEnumInt64(buffer, 0)
    fbeResult.Int64b4 = NewFinalModelEnumInt64(buffer, 0)
    fbeResult.Int64b5 = NewFinalModelEnumInt64(buffer, 0)
    fbeResult.Uint64b0 = NewFinalModelEnumUInt64(buffer, 0)
    fbeResult.Uint64b1 = NewFinalModelEnumUInt64(buffer, 0)
    fbeResult.Uint64b2 = NewFinalModelEnumUInt64(buffer, 0)
    fbeResult.Uint64b3 = NewFinalModelEnumUInt64(buffer, 0)
    fbeResult.Uint64b4 = NewFinalModelEnumUInt64(buffer, 0)
    fbeResult.Uint64b5 = NewFinalModelEnumUInt64(buffer, 0)
    return &fbeResult
}

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

// Get the final size
func (fm *FinalModelEnums) FBESize() int { return 0 }

// Get the final extra size
func (fm *FinalModelEnums) FBEExtra() int { return 0 }

// Get the final type
func (fm *FinalModelEnums) FBEType() int { return 1 }

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

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

// Check if the struct value is valid
func (fm *FinalModelEnums) Verify() int {
    fm.buffer.Shift(fm.FBEOffset())
    fbeResult := fm.VerifyFields()
    fm.buffer.Unshift(fm.FBEOffset())
    return fbeResult
}

// Check if the struct fields are valid
func (fm *FinalModelEnums) VerifyFields() int {
    fbeCurrentOffset := 0
    fbeFieldSize := 0


    fm.Byte0.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Byte0.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Byte1.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Byte1.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Byte2.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Byte2.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Byte3.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Byte3.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Byte4.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Byte4.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Byte5.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Byte5.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Char0.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Char0.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Char1.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Char1.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Char2.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Char2.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Char3.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Char3.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Char4.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Char4.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Char5.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Char5.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Wchar0.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Wchar0.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Wchar1.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Wchar1.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Wchar2.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Wchar2.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Wchar3.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Wchar3.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Wchar4.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Wchar4.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Wchar5.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Wchar5.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Int8b0.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Int8b0.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Int8b1.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Int8b1.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Int8b2.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Int8b2.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Int8b3.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Int8b3.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Int8b4.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Int8b4.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Int8b5.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Int8b5.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Uint8b0.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Uint8b0.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Uint8b1.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Uint8b1.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Uint8b2.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Uint8b2.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Uint8b3.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Uint8b3.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Uint8b4.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Uint8b4.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Uint8b5.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Uint8b5.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Int16b0.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Int16b0.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Int16b1.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Int16b1.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Int16b2.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Int16b2.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Int16b3.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Int16b3.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Int16b4.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Int16b4.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Int16b5.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Int16b5.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Uint16b0.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Uint16b0.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Uint16b1.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Uint16b1.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Uint16b2.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Uint16b2.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Uint16b3.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Uint16b3.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Uint16b4.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Uint16b4.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Uint16b5.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Uint16b5.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Int32b0.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Int32b0.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Int32b1.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Int32b1.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Int32b2.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Int32b2.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Int32b3.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Int32b3.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Int32b4.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Int32b4.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Int32b5.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Int32b5.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Uint32b0.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Uint32b0.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Uint32b1.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Uint32b1.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Uint32b2.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Uint32b2.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Uint32b3.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Uint32b3.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Uint32b4.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Uint32b4.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Uint32b5.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Uint32b5.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Int64b0.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Int64b0.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Int64b1.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Int64b1.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Int64b2.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Int64b2.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Int64b3.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Int64b3.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Int64b4.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Int64b4.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Int64b5.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Int64b5.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Uint64b0.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Uint64b0.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Uint64b1.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Uint64b1.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Uint64b2.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Uint64b2.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Uint64b3.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Uint64b3.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Uint64b4.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Uint64b4.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    fm.Uint64b5.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize = fm.Uint64b5.Verify(); fbeFieldSize == fbe.MaxInt {
        return fbe.MaxInt
    }
    fbeCurrentOffset += fbeFieldSize

    return fbeCurrentOffset
}

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

// Get the struct value by the given pointer
func (fm *FinalModelEnums) GetValue(fbeValue *Enums) (int, error) {
    fm.buffer.Shift(fm.FBEOffset())
    fbeSize, err := fm.GetFields(fbeValue)
    fm.buffer.Unshift(fm.FBEOffset())
    return fbeSize, err
}

// Get the struct fields values
func (fm *FinalModelEnums) GetFields(fbeValue *Enums) (int, error) {
    var err error = nil
    fbeCurrentSize := 0
    fbeCurrentOffset := 0
    fbeFieldSize := 0

    fm.Byte0.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Byte0.GetValue(&fbeValue.Byte0); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Byte1.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Byte1.GetValue(&fbeValue.Byte1); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Byte2.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Byte2.GetValue(&fbeValue.Byte2); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Byte3.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Byte3.GetValue(&fbeValue.Byte3); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Byte4.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Byte4.GetValue(&fbeValue.Byte4); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Byte5.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Byte5.GetValue(&fbeValue.Byte5); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Char0.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Char0.GetValue(&fbeValue.Char0); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Char1.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Char1.GetValue(&fbeValue.Char1); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Char2.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Char2.GetValue(&fbeValue.Char2); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Char3.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Char3.GetValue(&fbeValue.Char3); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Char4.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Char4.GetValue(&fbeValue.Char4); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Char5.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Char5.GetValue(&fbeValue.Char5); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Wchar0.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Wchar0.GetValue(&fbeValue.Wchar0); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Wchar1.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Wchar1.GetValue(&fbeValue.Wchar1); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Wchar2.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Wchar2.GetValue(&fbeValue.Wchar2); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Wchar3.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Wchar3.GetValue(&fbeValue.Wchar3); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Wchar4.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Wchar4.GetValue(&fbeValue.Wchar4); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Wchar5.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Wchar5.GetValue(&fbeValue.Wchar5); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Int8b0.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Int8b0.GetValue(&fbeValue.Int8b0); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Int8b1.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Int8b1.GetValue(&fbeValue.Int8b1); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Int8b2.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Int8b2.GetValue(&fbeValue.Int8b2); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Int8b3.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Int8b3.GetValue(&fbeValue.Int8b3); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Int8b4.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Int8b4.GetValue(&fbeValue.Int8b4); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Int8b5.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Int8b5.GetValue(&fbeValue.Int8b5); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Uint8b0.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Uint8b0.GetValue(&fbeValue.Uint8b0); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Uint8b1.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Uint8b1.GetValue(&fbeValue.Uint8b1); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Uint8b2.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Uint8b2.GetValue(&fbeValue.Uint8b2); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Uint8b3.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Uint8b3.GetValue(&fbeValue.Uint8b3); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Uint8b4.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Uint8b4.GetValue(&fbeValue.Uint8b4); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Uint8b5.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Uint8b5.GetValue(&fbeValue.Uint8b5); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Int16b0.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Int16b0.GetValue(&fbeValue.Int16b0); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Int16b1.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Int16b1.GetValue(&fbeValue.Int16b1); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Int16b2.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Int16b2.GetValue(&fbeValue.Int16b2); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Int16b3.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Int16b3.GetValue(&fbeValue.Int16b3); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Int16b4.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Int16b4.GetValue(&fbeValue.Int16b4); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Int16b5.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Int16b5.GetValue(&fbeValue.Int16b5); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Uint16b0.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Uint16b0.GetValue(&fbeValue.Uint16b0); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Uint16b1.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Uint16b1.GetValue(&fbeValue.Uint16b1); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Uint16b2.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Uint16b2.GetValue(&fbeValue.Uint16b2); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Uint16b3.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Uint16b3.GetValue(&fbeValue.Uint16b3); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Uint16b4.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Uint16b4.GetValue(&fbeValue.Uint16b4); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Uint16b5.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Uint16b5.GetValue(&fbeValue.Uint16b5); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Int32b0.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Int32b0.GetValue(&fbeValue.Int32b0); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Int32b1.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Int32b1.GetValue(&fbeValue.Int32b1); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Int32b2.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Int32b2.GetValue(&fbeValue.Int32b2); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Int32b3.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Int32b3.GetValue(&fbeValue.Int32b3); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Int32b4.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Int32b4.GetValue(&fbeValue.Int32b4); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Int32b5.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Int32b5.GetValue(&fbeValue.Int32b5); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Uint32b0.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Uint32b0.GetValue(&fbeValue.Uint32b0); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Uint32b1.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Uint32b1.GetValue(&fbeValue.Uint32b1); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Uint32b2.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Uint32b2.GetValue(&fbeValue.Uint32b2); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Uint32b3.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Uint32b3.GetValue(&fbeValue.Uint32b3); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Uint32b4.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Uint32b4.GetValue(&fbeValue.Uint32b4); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Uint32b5.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Uint32b5.GetValue(&fbeValue.Uint32b5); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Int64b0.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Int64b0.GetValue(&fbeValue.Int64b0); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Int64b1.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Int64b1.GetValue(&fbeValue.Int64b1); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Int64b2.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Int64b2.GetValue(&fbeValue.Int64b2); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Int64b3.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Int64b3.GetValue(&fbeValue.Int64b3); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Int64b4.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Int64b4.GetValue(&fbeValue.Int64b4); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Int64b5.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Int64b5.GetValue(&fbeValue.Int64b5); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Uint64b0.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Uint64b0.GetValue(&fbeValue.Uint64b0); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Uint64b1.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Uint64b1.GetValue(&fbeValue.Uint64b1); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Uint64b2.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Uint64b2.GetValue(&fbeValue.Uint64b2); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Uint64b3.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Uint64b3.GetValue(&fbeValue.Uint64b3); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Uint64b4.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Uint64b4.GetValue(&fbeValue.Uint64b4); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Uint64b5.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Uint64b5.GetValue(&fbeValue.Uint64b5); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    return fbeCurrentSize, err
}

// Set the struct value
func (fm *FinalModelEnums) Set(fbeValue *Enums) (int, error) {
    fm.buffer.Shift(fm.FBEOffset())
    fbeResult, err := fm.SetFields(fbeValue)
    fm.buffer.Unshift(fm.FBEOffset())
    return fbeResult, err
}

// Set the struct fields values
func (fm *FinalModelEnums) SetFields(fbeValue *Enums) (int, error) {
    var err error = nil
    fbeCurrentSize := 0
    fbeCurrentOffset := 0
    fbeFieldSize := 0

    fm.Byte0.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Byte0.Set(&fbeValue.Byte0); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Byte1.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Byte1.Set(&fbeValue.Byte1); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Byte2.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Byte2.Set(&fbeValue.Byte2); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Byte3.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Byte3.Set(&fbeValue.Byte3); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Byte4.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Byte4.Set(&fbeValue.Byte4); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Byte5.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Byte5.Set(&fbeValue.Byte5); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Char0.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Char0.Set(&fbeValue.Char0); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Char1.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Char1.Set(&fbeValue.Char1); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Char2.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Char2.Set(&fbeValue.Char2); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Char3.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Char3.Set(&fbeValue.Char3); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Char4.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Char4.Set(&fbeValue.Char4); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Char5.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Char5.Set(&fbeValue.Char5); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Wchar0.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Wchar0.Set(&fbeValue.Wchar0); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Wchar1.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Wchar1.Set(&fbeValue.Wchar1); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Wchar2.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Wchar2.Set(&fbeValue.Wchar2); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Wchar3.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Wchar3.Set(&fbeValue.Wchar3); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Wchar4.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Wchar4.Set(&fbeValue.Wchar4); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Wchar5.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Wchar5.Set(&fbeValue.Wchar5); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Int8b0.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Int8b0.Set(&fbeValue.Int8b0); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Int8b1.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Int8b1.Set(&fbeValue.Int8b1); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Int8b2.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Int8b2.Set(&fbeValue.Int8b2); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Int8b3.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Int8b3.Set(&fbeValue.Int8b3); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Int8b4.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Int8b4.Set(&fbeValue.Int8b4); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Int8b5.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Int8b5.Set(&fbeValue.Int8b5); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Uint8b0.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Uint8b0.Set(&fbeValue.Uint8b0); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Uint8b1.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Uint8b1.Set(&fbeValue.Uint8b1); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Uint8b2.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Uint8b2.Set(&fbeValue.Uint8b2); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Uint8b3.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Uint8b3.Set(&fbeValue.Uint8b3); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Uint8b4.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Uint8b4.Set(&fbeValue.Uint8b4); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Uint8b5.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Uint8b5.Set(&fbeValue.Uint8b5); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Int16b0.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Int16b0.Set(&fbeValue.Int16b0); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Int16b1.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Int16b1.Set(&fbeValue.Int16b1); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Int16b2.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Int16b2.Set(&fbeValue.Int16b2); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Int16b3.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Int16b3.Set(&fbeValue.Int16b3); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Int16b4.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Int16b4.Set(&fbeValue.Int16b4); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Int16b5.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Int16b5.Set(&fbeValue.Int16b5); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Uint16b0.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Uint16b0.Set(&fbeValue.Uint16b0); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Uint16b1.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Uint16b1.Set(&fbeValue.Uint16b1); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Uint16b2.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Uint16b2.Set(&fbeValue.Uint16b2); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Uint16b3.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Uint16b3.Set(&fbeValue.Uint16b3); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Uint16b4.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Uint16b4.Set(&fbeValue.Uint16b4); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Uint16b5.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Uint16b5.Set(&fbeValue.Uint16b5); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Int32b0.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Int32b0.Set(&fbeValue.Int32b0); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Int32b1.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Int32b1.Set(&fbeValue.Int32b1); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Int32b2.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Int32b2.Set(&fbeValue.Int32b2); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Int32b3.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Int32b3.Set(&fbeValue.Int32b3); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Int32b4.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Int32b4.Set(&fbeValue.Int32b4); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Int32b5.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Int32b5.Set(&fbeValue.Int32b5); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Uint32b0.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Uint32b0.Set(&fbeValue.Uint32b0); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Uint32b1.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Uint32b1.Set(&fbeValue.Uint32b1); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Uint32b2.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Uint32b2.Set(&fbeValue.Uint32b2); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Uint32b3.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Uint32b3.Set(&fbeValue.Uint32b3); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Uint32b4.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Uint32b4.Set(&fbeValue.Uint32b4); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Uint32b5.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Uint32b5.Set(&fbeValue.Uint32b5); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Int64b0.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Int64b0.Set(&fbeValue.Int64b0); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Int64b1.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Int64b1.Set(&fbeValue.Int64b1); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Int64b2.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Int64b2.Set(&fbeValue.Int64b2); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Int64b3.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Int64b3.Set(&fbeValue.Int64b3); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Int64b4.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Int64b4.Set(&fbeValue.Int64b4); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Int64b5.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Int64b5.Set(&fbeValue.Int64b5); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Uint64b0.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Uint64b0.Set(&fbeValue.Uint64b0); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Uint64b1.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Uint64b1.Set(&fbeValue.Uint64b1); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Uint64b2.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Uint64b2.Set(&fbeValue.Uint64b2); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Uint64b3.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Uint64b3.Set(&fbeValue.Uint64b3); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Uint64b4.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Uint64b4.Set(&fbeValue.Uint64b4); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    fm.Uint64b5.SetFBEOffset(fbeCurrentOffset)
    if fbeFieldSize, err = fm.Uint64b5.Set(&fbeValue.Uint64b5); err != nil {
        return fbeCurrentSize, err
    }
    fbeCurrentOffset += fbeFieldSize
    fbeCurrentSize += fbeFieldSize

    return fbeCurrentSize, err
}
