NT-MDT data: Go parsing library

// Code generated by kaitai-struct-compiler from a .ksy source file. DO NOT EDIT.

import (
	"github.com/kaitai-io/kaitai_struct_go_runtime/kaitai"
	"bytes"
	"io"
	"golang.org/x/text/encoding/charmap"
	"golang.org/x/text/encoding/unicode"
)


/**
 * A native file format of NT-MDT scientific software. Usually contains
 * any of:
 * 
 * * [Scanning probe](https://en.wikipedia.org/wiki/Scanning_probe_microscopy) microscopy scans and spectra
 * * [Raman spectra](https://en.wikipedia.org/wiki/Raman_spectroscopy)
 * * results of their analysis
 * 
 * Some examples of mdt files can be downloaded at:
 * 
 * * <https://www.ntmdt-si.ru/resources/scan-gallery>
 * * <http://callistosoft.narod.ru/Resources/Mdt.zip>
 * @see <a href="https://svn.code.sf.net/p/gwyddion/code/trunk/gwyddion/modules/file/nt-mdt.c">Source</a>
 */

type NtMdt_AdcMode int
const (
	NtMdt_AdcMode__Height NtMdt_AdcMode = 0
	NtMdt_AdcMode__Dfl NtMdt_AdcMode = 1
	NtMdt_AdcMode__LateralF NtMdt_AdcMode = 2
	NtMdt_AdcMode__BiasV NtMdt_AdcMode = 3
	NtMdt_AdcMode__Current NtMdt_AdcMode = 4
	NtMdt_AdcMode__FbOut NtMdt_AdcMode = 5
	NtMdt_AdcMode__Mag NtMdt_AdcMode = 6
	NtMdt_AdcMode__MagSin NtMdt_AdcMode = 7
	NtMdt_AdcMode__MagCos NtMdt_AdcMode = 8
	NtMdt_AdcMode__Rms NtMdt_AdcMode = 9
	NtMdt_AdcMode__CalcMag NtMdt_AdcMode = 10
	NtMdt_AdcMode__Phase1 NtMdt_AdcMode = 11
	NtMdt_AdcMode__Phase2 NtMdt_AdcMode = 12
	NtMdt_AdcMode__CalcPhase NtMdt_AdcMode = 13
	NtMdt_AdcMode__Ex1 NtMdt_AdcMode = 14
	NtMdt_AdcMode__Ex2 NtMdt_AdcMode = 15
	NtMdt_AdcMode__HvX NtMdt_AdcMode = 16
	NtMdt_AdcMode__HvY NtMdt_AdcMode = 17
	NtMdt_AdcMode__SnapBack NtMdt_AdcMode = 18
	NtMdt_AdcMode__False NtMdt_AdcMode = 255
)
var values_NtMdt_AdcMode = map[NtMdt_AdcMode]struct{}{0: {}, 1: {}, 2: {}, 3: {}, 4: {}, 5: {}, 6: {}, 7: {}, 8: {}, 9: {}, 10: {}, 11: {}, 12: {}, 13: {}, 14: {}, 15: {}, 16: {}, 17: {}, 18: {}, 255: {}}
func (v NtMdt_AdcMode) isDefined() bool {
	_, ok := values_NtMdt_AdcMode[v]
	return ok
}

type NtMdt_Consts int
const (
	NtMdt_Consts__FrameModeSize NtMdt_Consts = 8
	NtMdt_Consts__FrameHeaderSize NtMdt_Consts = 22
	NtMdt_Consts__AxisScalesSize NtMdt_Consts = 30
	NtMdt_Consts__FileHeaderSize NtMdt_Consts = 32
	NtMdt_Consts__SpectroVarsMinSize NtMdt_Consts = 38
	NtMdt_Consts__ScanVarsMinSize NtMdt_Consts = 77
)
var values_NtMdt_Consts = map[NtMdt_Consts]struct{}{8: {}, 22: {}, 30: {}, 32: {}, 38: {}, 77: {}}
func (v NtMdt_Consts) isDefined() bool {
	_, ok := values_NtMdt_Consts[v]
	return ok
}

type NtMdt_DataType int
const (
	NtMdt_DataType__Floatfix NtMdt_DataType = -65544
	NtMdt_DataType__Float80 NtMdt_DataType = -16138
	NtMdt_DataType__Float64 NtMdt_DataType = -13320
	NtMdt_DataType__Float48 NtMdt_DataType = -9990
	NtMdt_DataType__Float32 NtMdt_DataType = -5892
	NtMdt_DataType__Int64 NtMdt_DataType = -8
	NtMdt_DataType__Int32 NtMdt_DataType = -4
	NtMdt_DataType__Int16 NtMdt_DataType = -2
	NtMdt_DataType__Int8 NtMdt_DataType = -1
	NtMdt_DataType__Unknown0 NtMdt_DataType = 0
	NtMdt_DataType__Uint8 NtMdt_DataType = 1
	NtMdt_DataType__Uint16 NtMdt_DataType = 2
	NtMdt_DataType__Uint32 NtMdt_DataType = 4
	NtMdt_DataType__Uint64 NtMdt_DataType = 8
)
var values_NtMdt_DataType = map[NtMdt_DataType]struct{}{-65544: {}, -16138: {}, -13320: {}, -9990: {}, -5892: {}, -8: {}, -4: {}, -2: {}, -1: {}, 0: {}, 1: {}, 2: {}, 4: {}, 8: {}}
func (v NtMdt_DataType) isDefined() bool {
	_, ok := values_NtMdt_DataType[v]
	return ok
}

type NtMdt_SpmMode int
const (
	NtMdt_SpmMode__ConstantForce NtMdt_SpmMode = 0
	NtMdt_SpmMode__ContactConstantHeight NtMdt_SpmMode = 1
	NtMdt_SpmMode__ContactError NtMdt_SpmMode = 2
	NtMdt_SpmMode__LateralForce NtMdt_SpmMode = 3
	NtMdt_SpmMode__ForceModulation NtMdt_SpmMode = 4
	NtMdt_SpmMode__SpreadingResistanceImaging NtMdt_SpmMode = 5
	NtMdt_SpmMode__SemicontactTopography NtMdt_SpmMode = 6
	NtMdt_SpmMode__SemicontactError NtMdt_SpmMode = 7
	NtMdt_SpmMode__PhaseContrast NtMdt_SpmMode = 8
	NtMdt_SpmMode__AcMagneticForce NtMdt_SpmMode = 9
	NtMdt_SpmMode__DcMagneticForce NtMdt_SpmMode = 10
	NtMdt_SpmMode__ElectrostaticForce NtMdt_SpmMode = 11
	NtMdt_SpmMode__CapacitanceContrast NtMdt_SpmMode = 12
	NtMdt_SpmMode__KelvinProbe NtMdt_SpmMode = 13
	NtMdt_SpmMode__ConstantCurrent NtMdt_SpmMode = 14
	NtMdt_SpmMode__BarrierHeight NtMdt_SpmMode = 15
	NtMdt_SpmMode__ConstantHeight NtMdt_SpmMode = 16
	NtMdt_SpmMode__Afam NtMdt_SpmMode = 17
	NtMdt_SpmMode__ContactEfm NtMdt_SpmMode = 18
	NtMdt_SpmMode__ShearForceTopography NtMdt_SpmMode = 19
	NtMdt_SpmMode__Sfom NtMdt_SpmMode = 20
	NtMdt_SpmMode__ContactCapacitance NtMdt_SpmMode = 21
	NtMdt_SpmMode__SnomTransmission NtMdt_SpmMode = 22
	NtMdt_SpmMode__SnomReflection NtMdt_SpmMode = 23
	NtMdt_SpmMode__SnomAll NtMdt_SpmMode = 24
	NtMdt_SpmMode__Snom NtMdt_SpmMode = 25
)
var values_NtMdt_SpmMode = map[NtMdt_SpmMode]struct{}{0: {}, 1: {}, 2: {}, 3: {}, 4: {}, 5: {}, 6: {}, 7: {}, 8: {}, 9: {}, 10: {}, 11: {}, 12: {}, 13: {}, 14: {}, 15: {}, 16: {}, 17: {}, 18: {}, 19: {}, 20: {}, 21: {}, 22: {}, 23: {}, 24: {}, 25: {}}
func (v NtMdt_SpmMode) isDefined() bool {
	_, ok := values_NtMdt_SpmMode[v]
	return ok
}

type NtMdt_SpmTechnique int
const (
	NtMdt_SpmTechnique__ContactMode NtMdt_SpmTechnique = 0
	NtMdt_SpmTechnique__SemicontactMode NtMdt_SpmTechnique = 1
	NtMdt_SpmTechnique__TunnelCurrent NtMdt_SpmTechnique = 2
	NtMdt_SpmTechnique__Snom NtMdt_SpmTechnique = 3
)
var values_NtMdt_SpmTechnique = map[NtMdt_SpmTechnique]struct{}{0: {}, 1: {}, 2: {}, 3: {}}
func (v NtMdt_SpmTechnique) isDefined() bool {
	_, ok := values_NtMdt_SpmTechnique[v]
	return ok
}

type NtMdt_Unit int
const (
	NtMdt_Unit__RamanShift NtMdt_Unit = -10
	NtMdt_Unit__Reserved0 NtMdt_Unit = -9
	NtMdt_Unit__Reserved1 NtMdt_Unit = -8
	NtMdt_Unit__Reserved2 NtMdt_Unit = -7
	NtMdt_Unit__Reserved3 NtMdt_Unit = -6
	NtMdt_Unit__Meter NtMdt_Unit = -5
	NtMdt_Unit__CentiMeter NtMdt_Unit = -4
	NtMdt_Unit__MilliMeter NtMdt_Unit = -3
	NtMdt_Unit__MicroMeter NtMdt_Unit = -2
	NtMdt_Unit__NanoMeter NtMdt_Unit = -1
	NtMdt_Unit__Angstrom NtMdt_Unit = 0
	NtMdt_Unit__NanoAmpere NtMdt_Unit = 1
	NtMdt_Unit__Volt NtMdt_Unit = 2
	NtMdt_Unit__None NtMdt_Unit = 3
	NtMdt_Unit__KiloHertz NtMdt_Unit = 4
	NtMdt_Unit__Degrees NtMdt_Unit = 5
	NtMdt_Unit__Percent NtMdt_Unit = 6
	NtMdt_Unit__CelsiusDegree NtMdt_Unit = 7
	NtMdt_Unit__VoltHigh NtMdt_Unit = 8
	NtMdt_Unit__Second NtMdt_Unit = 9
	NtMdt_Unit__MilliSecond NtMdt_Unit = 10
	NtMdt_Unit__MicroSecond NtMdt_Unit = 11
	NtMdt_Unit__NanoSecond NtMdt_Unit = 12
	NtMdt_Unit__Counts NtMdt_Unit = 13
	NtMdt_Unit__Pixels NtMdt_Unit = 14
	NtMdt_Unit__ReservedSfom0 NtMdt_Unit = 15
	NtMdt_Unit__ReservedSfom1 NtMdt_Unit = 16
	NtMdt_Unit__ReservedSfom2 NtMdt_Unit = 17
	NtMdt_Unit__ReservedSfom3 NtMdt_Unit = 18
	NtMdt_Unit__ReservedSfom4 NtMdt_Unit = 19
	NtMdt_Unit__Ampere2 NtMdt_Unit = 20
	NtMdt_Unit__MilliAmpere NtMdt_Unit = 21
	NtMdt_Unit__MicroAmpere NtMdt_Unit = 22
	NtMdt_Unit__NanoAmpere2 NtMdt_Unit = 23
	NtMdt_Unit__PicoAmpere NtMdt_Unit = 24
	NtMdt_Unit__Volt2 NtMdt_Unit = 25
	NtMdt_Unit__MilliVolt NtMdt_Unit = 26
	NtMdt_Unit__MicroVolt NtMdt_Unit = 27
	NtMdt_Unit__NanoVolt NtMdt_Unit = 28
	NtMdt_Unit__PicoVolt NtMdt_Unit = 29
	NtMdt_Unit__Newton NtMdt_Unit = 30
	NtMdt_Unit__MilliNewton NtMdt_Unit = 31
	NtMdt_Unit__MicroNewton NtMdt_Unit = 32
	NtMdt_Unit__NanoNewton NtMdt_Unit = 33
	NtMdt_Unit__PicoNewton NtMdt_Unit = 34
	NtMdt_Unit__ReservedDos0 NtMdt_Unit = 35
	NtMdt_Unit__ReservedDos1 NtMdt_Unit = 36
	NtMdt_Unit__ReservedDos2 NtMdt_Unit = 37
	NtMdt_Unit__ReservedDos3 NtMdt_Unit = 38
	NtMdt_Unit__ReservedDos4 NtMdt_Unit = 39
)
var values_NtMdt_Unit = map[NtMdt_Unit]struct{}{-10: {}, -9: {}, -8: {}, -7: {}, -6: {}, -5: {}, -4: {}, -3: {}, -2: {}, -1: {}, 0: {}, 1: {}, 2: {}, 3: {}, 4: {}, 5: {}, 6: {}, 7: {}, 8: {}, 9: {}, 10: {}, 11: {}, 12: {}, 13: {}, 14: {}, 15: {}, 16: {}, 17: {}, 18: {}, 19: {}, 20: {}, 21: {}, 22: {}, 23: {}, 24: {}, 25: {}, 26: {}, 27: {}, 28: {}, 29: {}, 30: {}, 31: {}, 32: {}, 33: {}, 34: {}, 35: {}, 36: {}, 37: {}, 38: {}, 39: {}}
func (v NtMdt_Unit) isDefined() bool {
	_, ok := values_NtMdt_Unit[v]
	return ok
}

type NtMdt_XmlParamType int
const (
	NtMdt_XmlParamType__None NtMdt_XmlParamType = 0
	NtMdt_XmlParamType__LaserWavelength NtMdt_XmlParamType = 1
	NtMdt_XmlParamType__Units NtMdt_XmlParamType = 2
	NtMdt_XmlParamType__DataArray NtMdt_XmlParamType = 255
)
var values_NtMdt_XmlParamType = map[NtMdt_XmlParamType]struct{}{0: {}, 1: {}, 2: {}, 255: {}}
func (v NtMdt_XmlParamType) isDefined() bool {
	_, ok := values_NtMdt_XmlParamType[v]
	return ok
}

type NtMdt_XmlScanLocation int
const (
	NtMdt_XmlScanLocation__Hlt NtMdt_XmlScanLocation = 0
	NtMdt_XmlScanLocation__Hlb NtMdt_XmlScanLocation = 1
	NtMdt_XmlScanLocation__Hrt NtMdt_XmlScanLocation = 2
	NtMdt_XmlScanLocation__Hrb NtMdt_XmlScanLocation = 3
	NtMdt_XmlScanLocation__Vlt NtMdt_XmlScanLocation = 4
	NtMdt_XmlScanLocation__Vlb NtMdt_XmlScanLocation = 5
	NtMdt_XmlScanLocation__Vrt NtMdt_XmlScanLocation = 6
	NtMdt_XmlScanLocation__Vrb NtMdt_XmlScanLocation = 7
)
var values_NtMdt_XmlScanLocation = map[NtMdt_XmlScanLocation]struct{}{0: {}, 1: {}, 2: {}, 3: {}, 4: {}, 5: {}, 6: {}, 7: {}}
func (v NtMdt_XmlScanLocation) isDefined() bool {
	_, ok := values_NtMdt_XmlScanLocation[v]
	return ok
}
type NtMdt struct {
	Signature []byte
	Size uint32
	Reserved0 []byte
	LastFrame uint16
	Reserved1 []byte
	WrondDoc []byte
	Frames *NtMdt_Framez
	_io *kaitai.Stream
	_root *NtMdt
	_parent kaitai.Struct
	_raw_Frames []byte
}
func NewNtMdt() *NtMdt {
	return &NtMdt{
	}
}

func (this NtMdt) IO_() *kaitai.Stream {
	return this._io
}

func (this *NtMdt) Read(io *kaitai.Stream, parent kaitai.Struct, root *NtMdt) (err error) {
	this._io = io
	this._parent = parent
	this._root = root

	tmp1, err := this._io.ReadBytes(int(4))
	if err != nil {
		return err
	}
	tmp1 = tmp1
	this.Signature = tmp1
	if !(bytes.Equal(this.Signature, []uint8{1, 176, 147, 255})) {
		return kaitai.NewValidationNotEqualError([]uint8{1, 176, 147, 255}, this.Signature, this._io, "/seq/0")
	}
	tmp2, err := this._io.ReadU4le()
	if err != nil {
		return err
	}
	this.Size = uint32(tmp2)
	tmp3, err := this._io.ReadBytes(int(4))
	if err != nil {
		return err
	}
	tmp3 = tmp3
	this.Reserved0 = tmp3
	tmp4, err := this._io.ReadU2le()
	if err != nil {
		return err
	}
	this.LastFrame = uint16(tmp4)
	tmp5, err := this._io.ReadBytes(int(18))
	if err != nil {
		return err
	}
	tmp5 = tmp5
	this.Reserved1 = tmp5
	tmp6, err := this._io.ReadBytes(int(1))
	if err != nil {
		return err
	}
	tmp6 = tmp6
	this.WrondDoc = tmp6
	tmp7, err := this._io.ReadBytes(int(this.Size))
	if err != nil {
		return err
	}
	tmp7 = tmp7
	this._raw_Frames = tmp7
	_io__raw_Frames := kaitai.NewStream(bytes.NewReader(this._raw_Frames))
	tmp8 := NewNtMdt_Framez()
	err = tmp8.Read(_io__raw_Frames, this, this._root)
	if err != nil {
		return err
	}
	this.Frames = tmp8
	return err
}

/**
 * File size (w/o header)
 */

/**
 * documentation specifies 32 bytes long header, but zeroth frame starts at 33th byte in reality
 */

type NtMdt_Frame_FrameType int
const (
	NtMdt_Frame_FrameType__Scanned NtMdt_Frame_FrameType = 0
	NtMdt_Frame_FrameType__Spectroscopy NtMdt_Frame_FrameType = 1
	NtMdt_Frame_FrameType__Text NtMdt_Frame_FrameType = 3
	NtMdt_Frame_FrameType__OldMda NtMdt_Frame_FrameType = 105
	NtMdt_Frame_FrameType__Mda NtMdt_Frame_FrameType = 106
	NtMdt_Frame_FrameType__Palette NtMdt_Frame_FrameType = 107
	NtMdt_Frame_FrameType__CurvesNew NtMdt_Frame_FrameType = 190
	NtMdt_Frame_FrameType__Curves NtMdt_Frame_FrameType = 201
)
var values_NtMdt_Frame_FrameType = map[NtMdt_Frame_FrameType]struct{}{0: {}, 1: {}, 3: {}, 105: {}, 106: {}, 107: {}, 190: {}, 201: {}}
func (v NtMdt_Frame_FrameType) isDefined() bool {
	_, ok := values_NtMdt_Frame_FrameType[v]
	return ok
}
type NtMdt_Frame struct {
	Size uint32
	Main *NtMdt_Frame_FrameMain
	_io *kaitai.Stream
	_root *NtMdt
	_parent *NtMdt_Framez
	_raw_Main []byte
}
func NewNtMdt_Frame() *NtMdt_Frame {
	return &NtMdt_Frame{
	}
}

func (this NtMdt_Frame) IO_() *kaitai.Stream {
	return this._io
}

func (this *NtMdt_Frame) Read(io *kaitai.Stream, parent *NtMdt_Framez, root *NtMdt) (err error) {
	this._io = io
	this._parent = parent
	this._root = root

	tmp9, err := this._io.ReadU4le()
	if err != nil {
		return err
	}
	this.Size = uint32(tmp9)
	tmp10, err := this._io.ReadBytes(int(this.Size - 4))
	if err != nil {
		return err
	}
	tmp10 = tmp10
	this._raw_Main = tmp10
	_io__raw_Main := kaitai.NewStream(bytes.NewReader(this._raw_Main))
	tmp11 := NewNtMdt_Frame_FrameMain()
	err = tmp11.Read(_io__raw_Main, this, this._root)
	if err != nil {
		return err
	}
	this.Main = tmp11
	return err
}

/**
 * h_sz
 */
type NtMdt_Frame_AxisScale struct {
	Offset float32
	Step float32
	Unit NtMdt_Unit
	_io *kaitai.Stream
	_root *NtMdt
	_parent kaitai.Struct
}
func NewNtMdt_Frame_AxisScale() *NtMdt_Frame_AxisScale {
	return &NtMdt_Frame_AxisScale{
	}
}

func (this NtMdt_Frame_AxisScale) IO_() *kaitai.Stream {
	return this._io
}

func (this *NtMdt_Frame_AxisScale) Read(io *kaitai.Stream, parent kaitai.Struct, root *NtMdt) (err error) {
	this._io = io
	this._parent = parent
	this._root = root

	tmp12, err := this._io.ReadF4le()
	if err != nil {
		return err
	}
	this.Offset = float32(tmp12)
	tmp13, err := this._io.ReadF4le()
	if err != nil {
		return err
	}
	this.Step = float32(tmp13)
	tmp14, err := this._io.ReadS2le()
	if err != nil {
		return err
	}
	this.Unit = NtMdt_Unit(tmp14)
	return err
}

/**
 * x_scale->offset = gwy_get_gfloat_le(&p);# r0 (physical units)
 */

/**
 * x_scale->step = gwy_get_gfloat_le(&p); r (physical units) x_scale->step = fabs(x_scale->step); if (!x_scale->step) {
 *   g_warning("x_scale.step == 0, changing to 1");
 *   x_scale->step = 1.0;
 * }
 */

/**
 * U
 */
type NtMdt_Frame_DateTime struct {
	Date *NtMdt_Frame_DateTime_Date
	Time *NtMdt_Frame_DateTime_Time
	_io *kaitai.Stream
	_root *NtMdt
	_parent *NtMdt_Frame_FrameMain
}
func NewNtMdt_Frame_DateTime() *NtMdt_Frame_DateTime {
	return &NtMdt_Frame_DateTime{
	}
}

func (this NtMdt_Frame_DateTime) IO_() *kaitai.Stream {
	return this._io
}

func (this *NtMdt_Frame_DateTime) Read(io *kaitai.Stream, parent *NtMdt_Frame_FrameMain, root *NtMdt) (err error) {
	this._io = io
	this._parent = parent
	this._root = root

	tmp15 := NewNtMdt_Frame_DateTime_Date()
	err = tmp15.Read(this._io, this, this._root)
	if err != nil {
		return err
	}
	this.Date = tmp15
	tmp16 := NewNtMdt_Frame_DateTime_Time()
	err = tmp16.Read(this._io, this, this._root)
	if err != nil {
		return err
	}
	this.Time = tmp16
	return err
}
type NtMdt_Frame_DateTime_Date struct {
	Year uint16
	Month uint16
	Day uint16
	_io *kaitai.Stream
	_root *NtMdt
	_parent *NtMdt_Frame_DateTime
}
func NewNtMdt_Frame_DateTime_Date() *NtMdt_Frame_DateTime_Date {
	return &NtMdt_Frame_DateTime_Date{
	}
}

func (this NtMdt_Frame_DateTime_Date) IO_() *kaitai.Stream {
	return this._io
}

func (this *NtMdt_Frame_DateTime_Date) Read(io *kaitai.Stream, parent *NtMdt_Frame_DateTime, root *NtMdt) (err error) {
	this._io = io
	this._parent = parent
	this._root = root

	tmp17, err := this._io.ReadU2le()
	if err != nil {
		return err
	}
	this.Year = uint16(tmp17)
	tmp18, err := this._io.ReadU2le()
	if err != nil {
		return err
	}
	this.Month = uint16(tmp18)
	tmp19, err := this._io.ReadU2le()
	if err != nil {
		return err
	}
	this.Day = uint16(tmp19)
	return err
}

/**
 * h_yea
 */

/**
 * h_mon
 */

/**
 * h_day
 */
type NtMdt_Frame_DateTime_Time struct {
	Hour uint16
	Min uint16
	Sec uint16
	_io *kaitai.Stream
	_root *NtMdt
	_parent *NtMdt_Frame_DateTime
}
func NewNtMdt_Frame_DateTime_Time() *NtMdt_Frame_DateTime_Time {
	return &NtMdt_Frame_DateTime_Time{
	}
}

func (this NtMdt_Frame_DateTime_Time) IO_() *kaitai.Stream {
	return this._io
}

func (this *NtMdt_Frame_DateTime_Time) Read(io *kaitai.Stream, parent *NtMdt_Frame_DateTime, root *NtMdt) (err error) {
	this._io = io
	this._parent = parent
	this._root = root

	tmp20, err := this._io.ReadU2le()
	if err != nil {
		return err
	}
	this.Hour = uint16(tmp20)
	tmp21, err := this._io.ReadU2le()
	if err != nil {
		return err
	}
	this.Min = uint16(tmp21)
	tmp22, err := this._io.ReadU2le()
	if err != nil {
		return err
	}
	this.Sec = uint16(tmp22)
	return err
}

/**
 * h_h
 */

/**
 * h_m
 */

/**
 * h_s
 */
type NtMdt_Frame_Dots struct {
	FmNdots uint16
	CoordHeader *NtMdt_Frame_Dots_DotsHeader
	Coordinates []*NtMdt_Frame_Dots_DotsData
	Data []*NtMdt_Frame_Dots_DataLinez
	_io *kaitai.Stream
	_root *NtMdt
	_parent kaitai.Struct
}
func NewNtMdt_Frame_Dots() *NtMdt_Frame_Dots {
	return &NtMdt_Frame_Dots{
	}
}

func (this NtMdt_Frame_Dots) IO_() *kaitai.Stream {
	return this._io
}

func (this *NtMdt_Frame_Dots) Read(io *kaitai.Stream, parent kaitai.Struct, root *NtMdt) (err error) {
	this._io = io
	this._parent = parent
	this._root = root

	tmp23, err := this._io.ReadU2le()
	if err != nil {
		return err
	}
	this.FmNdots = uint16(tmp23)
	if (this.FmNdots > 0) {
		tmp24 := NewNtMdt_Frame_Dots_DotsHeader()
		err = tmp24.Read(this._io, this, this._root)
		if err != nil {
			return err
		}
		this.CoordHeader = tmp24
	}
	for i := 0; i < int(this.FmNdots); i++ {
		_ = i
		tmp25 := NewNtMdt_Frame_Dots_DotsData()
		err = tmp25.Read(this._io, this, this._root)
		if err != nil {
			return err
		}
		this.Coordinates = append(this.Coordinates, tmp25)
	}
	for i := 0; i < int(this.FmNdots); i++ {
		_ = i
		tmp26 := NewNtMdt_Frame_Dots_DataLinez(i)
		err = tmp26.Read(this._io, this, this._root)
		if err != nil {
			return err
		}
		this.Data = append(this.Data, tmp26)
	}
	return err
}
type NtMdt_Frame_Dots_DataLinez struct {
	Forward []int16
	Backward []int16
	Index uint16
	_io *kaitai.Stream
	_root *NtMdt
	_parent *NtMdt_Frame_Dots
}
func NewNtMdt_Frame_Dots_DataLinez(index uint16) *NtMdt_Frame_Dots_DataLinez {
	return &NtMdt_Frame_Dots_DataLinez{
		Index: index,
	}
}

func (this NtMdt_Frame_Dots_DataLinez) IO_() *kaitai.Stream {
	return this._io
}

func (this *NtMdt_Frame_Dots_DataLinez) Read(io *kaitai.Stream, parent *NtMdt_Frame_Dots, root *NtMdt) (err error) {
	this._io = io
	this._parent = parent
	this._root = root

	for i := 0; i < int(this._parent.Coordinates[this.Index].ForwardSize); i++ {
		_ = i
		tmp27, err := this._io.ReadS2le()
		if err != nil {
			return err
		}
		this.Forward = append(this.Forward, tmp27)
	}
	for i := 0; i < int(this._parent.Coordinates[this.Index].BackwardSize); i++ {
		_ = i
		tmp28, err := this._io.ReadS2le()
		if err != nil {
			return err
		}
		this.Backward = append(this.Backward, tmp28)
	}
	return err
}
type NtMdt_Frame_Dots_DotsData struct {
	CoordX float32
	CoordY float32
	ForwardSize int32
	BackwardSize int32
	_io *kaitai.Stream
	_root *NtMdt
	_parent *NtMdt_Frame_Dots
}
func NewNtMdt_Frame_Dots_DotsData() *NtMdt_Frame_Dots_DotsData {
	return &NtMdt_Frame_Dots_DotsData{
	}
}

func (this NtMdt_Frame_Dots_DotsData) IO_() *kaitai.Stream {
	return this._io
}

func (this *NtMdt_Frame_Dots_DotsData) Read(io *kaitai.Stream, parent *NtMdt_Frame_Dots, root *NtMdt) (err error) {
	this._io = io
	this._parent = parent
	this._root = root

	tmp29, err := this._io.ReadF4le()
	if err != nil {
		return err
	}
	this.CoordX = float32(tmp29)
	tmp30, err := this._io.ReadF4le()
	if err != nil {
		return err
	}
	this.CoordY = float32(tmp30)
	tmp31, err := this._io.ReadS4le()
	if err != nil {
		return err
	}
	this.ForwardSize = int32(tmp31)
	tmp32, err := this._io.ReadS4le()
	if err != nil {
		return err
	}
	this.BackwardSize = int32(tmp32)
	return err
}
type NtMdt_Frame_Dots_DotsHeader struct {
	HeaderSize int32
	Header *NtMdt_Frame_Dots_DotsHeader_Header
	_io *kaitai.Stream
	_root *NtMdt
	_parent *NtMdt_Frame_Dots
	_raw_Header []byte
}
func NewNtMdt_Frame_Dots_DotsHeader() *NtMdt_Frame_Dots_DotsHeader {
	return &NtMdt_Frame_Dots_DotsHeader{
	}
}

func (this NtMdt_Frame_Dots_DotsHeader) IO_() *kaitai.Stream {
	return this._io
}

func (this *NtMdt_Frame_Dots_DotsHeader) Read(io *kaitai.Stream, parent *NtMdt_Frame_Dots, root *NtMdt) (err error) {
	this._io = io
	this._parent = parent
	this._root = root

	tmp33, err := this._io.ReadS4le()
	if err != nil {
		return err
	}
	this.HeaderSize = int32(tmp33)
	tmp34, err := this._io.ReadBytes(int(this.HeaderSize))
	if err != nil {
		return err
	}
	tmp34 = tmp34
	this._raw_Header = tmp34
	_io__raw_Header := kaitai.NewStream(bytes.NewReader(this._raw_Header))
	tmp35 := NewNtMdt_Frame_Dots_DotsHeader_Header()
	err = tmp35.Read(_io__raw_Header, this, this._root)
	if err != nil {
		return err
	}
	this.Header = tmp35
	return err
}
type NtMdt_Frame_Dots_DotsHeader_Header struct {
	CoordSize int32
	Version int32
	Xyunits NtMdt_Unit
	_io *kaitai.Stream
	_root *NtMdt
	_parent *NtMdt_Frame_Dots_DotsHeader
}
func NewNtMdt_Frame_Dots_DotsHeader_Header() *NtMdt_Frame_Dots_DotsHeader_Header {
	return &NtMdt_Frame_Dots_DotsHeader_Header{
	}
}

func (this NtMdt_Frame_Dots_DotsHeader_Header) IO_() *kaitai.Stream {
	return this._io
}

func (this *NtMdt_Frame_Dots_DotsHeader_Header) Read(io *kaitai.Stream, parent *NtMdt_Frame_Dots_DotsHeader, root *NtMdt) (err error) {
	this._io = io
	this._parent = parent
	this._root = root

	tmp36, err := this._io.ReadS4le()
	if err != nil {
		return err
	}
	this.CoordSize = int32(tmp36)
	tmp37, err := this._io.ReadS4le()
	if err != nil {
		return err
	}
	this.Version = int32(tmp37)
	tmp38, err := this._io.ReadS2le()
	if err != nil {
		return err
	}
	this.Xyunits = NtMdt_Unit(tmp38)
	return err
}
type NtMdt_Frame_FdCurvesNew struct {
	BlockCount uint32
	BlocksHeaders []*NtMdt_Frame_FdCurvesNew_BlockDescr
	BlocksNames []string
	BlocksData [][]byte
	_io *kaitai.Stream
	_root *NtMdt
	_parent *NtMdt_Frame_FrameMain
}
func NewNtMdt_Frame_FdCurvesNew() *NtMdt_Frame_FdCurvesNew {
	return &NtMdt_Frame_FdCurvesNew{
	}
}

func (this NtMdt_Frame_FdCurvesNew) IO_() *kaitai.Stream {
	return this._io
}

func (this *NtMdt_Frame_FdCurvesNew) Read(io *kaitai.Stream, parent *NtMdt_Frame_FrameMain, root *NtMdt) (err error) {
	this._io = io
	this._parent = parent
	this._root = root

	tmp39, err := this._io.ReadU4le()
	if err != nil {
		return err
	}
	this.BlockCount = uint32(tmp39)
	for i := 0; i < int(this.BlockCount); i++ {
		_ = i
		tmp40 := NewNtMdt_Frame_FdCurvesNew_BlockDescr()
		err = tmp40.Read(this._io, this, this._root)
		if err != nil {
			return err
		}
		this.BlocksHeaders = append(this.BlocksHeaders, tmp40)
	}
	for i := 0; i < int(this.BlockCount); i++ {
		_ = i
		tmp41, err := this._io.ReadBytes(int(this.BlocksHeaders[i].NameLen))
		if err != nil {
			return err
		}
		tmp41 = tmp41
		this.BlocksNames = append(this.BlocksNames, string(tmp41))
	}
	for i := 0; i < int(this.BlockCount); i++ {
		_ = i
		tmp42, err := this._io.ReadBytes(int(this.BlocksHeaders[i].Len))
		if err != nil {
			return err
		}
		tmp42 = tmp42
		this.BlocksData = append(this.BlocksData, tmp42)
	}
	return err
}
type NtMdt_Frame_FdCurvesNew_BlockDescr struct {
	NameLen uint32
	Len uint32
	_io *kaitai.Stream
	_root *NtMdt
	_parent *NtMdt_Frame_FdCurvesNew
}
func NewNtMdt_Frame_FdCurvesNew_BlockDescr() *NtMdt_Frame_FdCurvesNew_BlockDescr {
	return &NtMdt_Frame_FdCurvesNew_BlockDescr{
	}
}

func (this NtMdt_Frame_FdCurvesNew_BlockDescr) IO_() *kaitai.Stream {
	return this._io
}

func (this *NtMdt_Frame_FdCurvesNew_BlockDescr) Read(io *kaitai.Stream, parent *NtMdt_Frame_FdCurvesNew, root *NtMdt) (err error) {
	this._io = io
	this._parent = parent
	this._root = root

	tmp43, err := this._io.ReadU4le()
	if err != nil {
		return err
	}
	this.NameLen = uint32(tmp43)
	tmp44, err := this._io.ReadU4le()
	if err != nil {
		return err
	}
	this.Len = uint32(tmp44)
	return err
}
type NtMdt_Frame_FdMetaData struct {
	HeadSize uint32
	TotLen uint32
	Guids []*NtMdt_Uuid
	FrameStatus []byte
	NameSize uint32
	CommSize uint32
	ViewInfoSize uint32
	SpecSize uint32
	SourceInfoSize uint32
	VarSize uint32
	DataOffset uint32
	DataSize uint32
	Title string
	Xml string
	StructLen uint32
	ArraySize uint64
	CellSize uint32
	NDimensions uint32
	NMesurands uint32
	Dimensions []*NtMdt_Frame_FdMetaData_Calibration
	Mesurands []*NtMdt_Frame_FdMetaData_Calibration
	_io *kaitai.Stream
	_root *NtMdt
	_parent *NtMdt_Frame_FrameMain
	_raw_image []byte
	_f_image bool
	image *NtMdt_Frame_FdMetaData_Image
}
func NewNtMdt_Frame_FdMetaData() *NtMdt_Frame_FdMetaData {
	return &NtMdt_Frame_FdMetaData{
	}
}

func (this NtMdt_Frame_FdMetaData) IO_() *kaitai.Stream {
	return this._io
}

func (this *NtMdt_Frame_FdMetaData) Read(io *kaitai.Stream, parent *NtMdt_Frame_FrameMain, root *NtMdt) (err error) {
	this._io = io
	this._parent = parent
	this._root = root

	tmp45, err := this._io.ReadU4le()
	if err != nil {
		return err
	}
	this.HeadSize = uint32(tmp45)
	tmp46, err := this._io.ReadU4le()
	if err != nil {
		return err
	}
	this.TotLen = uint32(tmp46)
	for i := 0; i < int(2); i++ {
		_ = i
		tmp47 := NewNtMdt_Uuid()
		err = tmp47.Read(this._io, this, this._root)
		if err != nil {
			return err
		}
		this.Guids = append(this.Guids, tmp47)
	}
	tmp48, err := this._io.ReadBytes(int(4))
	if err != nil {
		return err
	}
	tmp48 = tmp48
	this.FrameStatus = tmp48
	tmp49, err := this._io.ReadU4le()
	if err != nil {
		return err
	}
	this.NameSize = uint32(tmp49)
	tmp50, err := this._io.ReadU4le()
	if err != nil {
		return err
	}
	this.CommSize = uint32(tmp50)
	tmp51, err := this._io.ReadU4le()
	if err != nil {
		return err
	}
	this.ViewInfoSize = uint32(tmp51)
	tmp52, err := this._io.ReadU4le()
	if err != nil {
		return err
	}
	this.SpecSize = uint32(tmp52)
	tmp53, err := this._io.ReadU4le()
	if err != nil {
		return err
	}
	this.SourceInfoSize = uint32(tmp53)
	tmp54, err := this._io.ReadU4le()
	if err != nil {
		return err
	}
	this.VarSize = uint32(tmp54)
	tmp55, err := this._io.ReadU4le()
	if err != nil {
		return err
	}
	this.DataOffset = uint32(tmp55)
	tmp56, err := this._io.ReadU4le()
	if err != nil {
		return err
	}
	this.DataSize = uint32(tmp56)
	tmp57, err := this._io.ReadBytes(int(this.NameSize))
	if err != nil {
		return err
	}
	tmp57 = tmp57
	this.Title = string(tmp57)
	tmp58, err := this._io.ReadBytes(int(this.CommSize))
	if err != nil {
		return err
	}
	tmp58 = tmp58
	this.Xml = string(tmp58)
	tmp59, err := this._io.ReadU4le()
	if err != nil {
		return err
	}
	this.StructLen = uint32(tmp59)
	tmp60, err := this._io.ReadU8le()
	if err != nil {
		return err
	}
	this.ArraySize = uint64(tmp60)
	tmp61, err := this._io.ReadU4le()
	if err != nil {
		return err
	}
	this.CellSize = uint32(tmp61)
	tmp62, err := this._io.ReadU4le()
	if err != nil {
		return err
	}
	this.NDimensions = uint32(tmp62)
	tmp63, err := this._io.ReadU4le()
	if err != nil {
		return err
	}
	this.NMesurands = uint32(tmp63)
	for i := 0; i < int(this.NDimensions); i++ {
		_ = i
		tmp64 := NewNtMdt_Frame_FdMetaData_Calibration()
		err = tmp64.Read(this._io, this, this._root)
		if err != nil {
			return err
		}
		this.Dimensions = append(this.Dimensions, tmp64)
	}
	for i := 0; i < int(this.NMesurands); i++ {
		_ = i
		tmp65 := NewNtMdt_Frame_FdMetaData_Calibration()
		err = tmp65.Read(this._io, this, this._root)
		if err != nil {
			return err
		}
		this.Mesurands = append(this.Mesurands, tmp65)
	}
	return err
}
func (this *NtMdt_Frame_FdMetaData) Image() (v *NtMdt_Frame_FdMetaData_Image, err error) {
	if (this._f_image) {
		return this.image, nil
	}
	this._f_image = true
	_pos, err := this._io.Pos()
	if err != nil {
		return nil, err
	}
	_, err = this._io.Seek(int64(this.DataOffset), io.SeekStart)
	if err != nil {
		return nil, err
	}
	tmp66, err := this._io.ReadBytes(int(this.DataSize))
	if err != nil {
		return nil, err
	}
	tmp66 = tmp66
	this._raw_image = tmp66
	_io__raw_image := kaitai.NewStream(bytes.NewReader(this._raw_image))
	tmp67 := NewNtMdt_Frame_FdMetaData_Image()
	err = tmp67.Read(_io__raw_image, this, this._root)
	if err != nil {
		return nil, err
	}
	this.image = tmp67
	_, err = this._io.Seek(_pos, io.SeekStart)
	if err != nil {
		return nil, err
	}
	return this.image, nil
}
type NtMdt_Frame_FdMetaData_Calibration struct {
	LenTot uint32
	LenStruct uint32
	LenName uint32
	LenComment uint32
	LenUnit uint32
	SiUnit uint64
	Accuracy float64
	FunctionIdAndDimensions uint64
	Bias float64
	Scale float64
	MinIndex uint64
	MaxIndex uint64
	DataType NtMdt_DataType
	LenAuthor uint32
	Name string
	Comment string
	Unit string
	Author string
	_io *kaitai.Stream
	_root *NtMdt
	_parent *NtMdt_Frame_FdMetaData
	_f_count bool
	count int
}
func NewNtMdt_Frame_FdMetaData_Calibration() *NtMdt_Frame_FdMetaData_Calibration {
	return &NtMdt_Frame_FdMetaData_Calibration{
	}
}

func (this NtMdt_Frame_FdMetaData_Calibration) IO_() *kaitai.Stream {
	return this._io
}

func (this *NtMdt_Frame_FdMetaData_Calibration) Read(io *kaitai.Stream, parent *NtMdt_Frame_FdMetaData, root *NtMdt) (err error) {
	this._io = io
	this._parent = parent
	this._root = root

	tmp68, err := this._io.ReadU4le()
	if err != nil {
		return err
	}
	this.LenTot = uint32(tmp68)
	tmp69, err := this._io.ReadU4le()
	if err != nil {
		return err
	}
	this.LenStruct = uint32(tmp69)
	tmp70, err := this._io.ReadU4le()
	if err != nil {
		return err
	}
	this.LenName = uint32(tmp70)
	tmp71, err := this._io.ReadU4le()
	if err != nil {
		return err
	}
	this.LenComment = uint32(tmp71)
	tmp72, err := this._io.ReadU4le()
	if err != nil {
		return err
	}
	this.LenUnit = uint32(tmp72)
	tmp73, err := this._io.ReadU8le()
	if err != nil {
		return err
	}
	this.SiUnit = uint64(tmp73)
	tmp74, err := this._io.ReadF8le()
	if err != nil {
		return err
	}
	this.Accuracy = float64(tmp74)
	tmp75, err := this._io.ReadU8le()
	if err != nil {
		return err
	}
	this.FunctionIdAndDimensions = uint64(tmp75)
	tmp76, err := this._io.ReadF8le()
	if err != nil {
		return err
	}
	this.Bias = float64(tmp76)
	tmp77, err := this._io.ReadF8le()
	if err != nil {
		return err
	}
	this.Scale = float64(tmp77)
	tmp78, err := this._io.ReadU8le()
	if err != nil {
		return err
	}
	this.MinIndex = uint64(tmp78)
	tmp79, err := this._io.ReadU8le()
	if err != nil {
		return err
	}
	this.MaxIndex = uint64(tmp79)
	tmp80, err := this._io.ReadS4le()
	if err != nil {
		return err
	}
	this.DataType = NtMdt_DataType(tmp80)
	tmp81, err := this._io.ReadU4le()
	if err != nil {
		return err
	}
	this.LenAuthor = uint32(tmp81)
	tmp82, err := this._io.ReadBytes(int(this.LenName))
	if err != nil {
		return err
	}
	tmp82 = tmp82
	this.Name = string(tmp82)
	tmp83, err := this._io.ReadBytes(int(this.LenComment))
	if err != nil {
		return err
	}
	tmp83 = tmp83
	this.Comment = string(tmp83)
	tmp84, err := this._io.ReadBytes(int(this.LenUnit))
	if err != nil {
		return err
	}
	tmp84 = tmp84
	this.Unit = string(tmp84)
	tmp85, err := this._io.ReadBytes(int(this.LenAuthor))
	if err != nil {
		return err
	}
	tmp85 = tmp85
	this.Author = string(tmp85)
	return err
}
func (this *NtMdt_Frame_FdMetaData_Calibration) Count() (v int, err error) {
	if (this._f_count) {
		return this.count, nil
	}
	this._f_count = true
	this.count = int((this.MaxIndex - this.MinIndex) + 1)
	return this.count, nil
}
type NtMdt_Frame_FdMetaData_Image struct {
	Image []*NtMdt_Frame_FdMetaData_Image_Vec
	_io *kaitai.Stream
	_root *NtMdt
	_parent *NtMdt_Frame_FdMetaData
}
func NewNtMdt_Frame_FdMetaData_Image() *NtMdt_Frame_FdMetaData_Image {
	return &NtMdt_Frame_FdMetaData_Image{
	}
}

func (this NtMdt_Frame_FdMetaData_Image) IO_() *kaitai.Stream {
	return this._io
}

func (this *NtMdt_Frame_FdMetaData_Image) Read(io *kaitai.Stream, parent *NtMdt_Frame_FdMetaData, root *NtMdt) (err error) {
	this._io = io
	this._parent = parent
	this._root = root

	for i := 0;; i++ {
		tmp86, err := this._io.EOF()
		if err != nil {
			return err
		}
		if tmp86 {
			break
		}
		tmp87 := NewNtMdt_Frame_FdMetaData_Image_Vec()
		err = tmp87.Read(this._io, this, this._root)
		if err != nil {
			return err
		}
		this.Image = append(this.Image, tmp87)
	}
	return err
}
type NtMdt_Frame_FdMetaData_Image_Vec struct {
	Items []float64
	_io *kaitai.Stream
	_root *NtMdt
	_parent *NtMdt_Frame_FdMetaData_Image
}
func NewNtMdt_Frame_FdMetaData_Image_Vec() *NtMdt_Frame_FdMetaData_Image_Vec {
	return &NtMdt_Frame_FdMetaData_Image_Vec{
	}
}

func (this NtMdt_Frame_FdMetaData_Image_Vec) IO_() *kaitai.Stream {
	return this._io
}

func (this *NtMdt_Frame_FdMetaData_Image_Vec) Read(io *kaitai.Stream, parent *NtMdt_Frame_FdMetaData_Image, root *NtMdt) (err error) {
	this._io = io
	this._parent = parent
	this._root = root

	for i := 0; i < int(this._parent._parent.NMesurands); i++ {
		_ = i
		switch (this._parent._parent.Mesurands[i].DataType) {
		case NtMdt_DataType__Float32:
			tmp88, err := this._io.ReadF4le()
			if err != nil {
				return err
			}
			this.Items = append(this.Items, tmp88)
		case NtMdt_DataType__Float64:
			tmp89, err := this._io.ReadF8le()
			if err != nil {
				return err
			}
			this.Items = append(this.Items, tmp89)
		case NtMdt_DataType__Int16:
			tmp90, err := this._io.ReadS2le()
			if err != nil {
				return err
			}
			this.Items = append(this.Items, tmp90)
		case NtMdt_DataType__Int32:
			tmp91, err := this._io.ReadS4le()
			if err != nil {
				return err
			}
			this.Items = append(this.Items, tmp91)
		case NtMdt_DataType__Int64:
			tmp92, err := this._io.ReadS8le()
			if err != nil {
				return err
			}
			this.Items = append(this.Items, tmp92)
		case NtMdt_DataType__Int8:
			tmp93, err := this._io.ReadS1()
			if err != nil {
				return err
			}
			this.Items = append(this.Items, tmp93)
		case NtMdt_DataType__Uint16:
			tmp94, err := this._io.ReadU2le()
			if err != nil {
				return err
			}
			this.Items = append(this.Items, tmp94)
		case NtMdt_DataType__Uint32:
			tmp95, err := this._io.ReadU4le()
			if err != nil {
				return err
			}
			this.Items = append(this.Items, tmp95)
		case NtMdt_DataType__Uint64:
			tmp96, err := this._io.ReadU8le()
			if err != nil {
				return err
			}
			this.Items = append(this.Items, tmp96)
		case NtMdt_DataType__Uint8:
			tmp97, err := this._io.ReadU1()
			if err != nil {
				return err
			}
			this.Items = append(this.Items, tmp97)
		}
	}
	return err
}

type NtMdt_Frame_FdScanned_InputSignal int
const (
	NtMdt_Frame_FdScanned_InputSignal__ExtensionSlot NtMdt_Frame_FdScanned_InputSignal = 0
	NtMdt_Frame_FdScanned_InputSignal__BiasV NtMdt_Frame_FdScanned_InputSignal = 1
	NtMdt_Frame_FdScanned_InputSignal__Ground NtMdt_Frame_FdScanned_InputSignal = 2
)
var values_NtMdt_Frame_FdScanned_InputSignal = map[NtMdt_Frame_FdScanned_InputSignal]struct{}{0: {}, 1: {}, 2: {}}
func (v NtMdt_Frame_FdScanned_InputSignal) isDefined() bool {
	_, ok := values_NtMdt_Frame_FdScanned_InputSignal[v]
	return ok
}

type NtMdt_Frame_FdScanned_LiftMode int
const (
	NtMdt_Frame_FdScanned_LiftMode__Step NtMdt_Frame_FdScanned_LiftMode = 0
	NtMdt_Frame_FdScanned_LiftMode__Fine NtMdt_Frame_FdScanned_LiftMode = 1
	NtMdt_Frame_FdScanned_LiftMode__Slope NtMdt_Frame_FdScanned_LiftMode = 2
)
var values_NtMdt_Frame_FdScanned_LiftMode = map[NtMdt_Frame_FdScanned_LiftMode]struct{}{0: {}, 1: {}, 2: {}}
func (v NtMdt_Frame_FdScanned_LiftMode) isDefined() bool {
	_, ok := values_NtMdt_Frame_FdScanned_LiftMode[v]
	return ok
}

type NtMdt_Frame_FdScanned_Mode int
const (
	NtMdt_Frame_FdScanned_Mode__Stm NtMdt_Frame_FdScanned_Mode = 0
	NtMdt_Frame_FdScanned_Mode__Afm NtMdt_Frame_FdScanned_Mode = 1
	NtMdt_Frame_FdScanned_Mode__Unknown2 NtMdt_Frame_FdScanned_Mode = 2
	NtMdt_Frame_FdScanned_Mode__Unknown3 NtMdt_Frame_FdScanned_Mode = 3
	NtMdt_Frame_FdScanned_Mode__Unknown4 NtMdt_Frame_FdScanned_Mode = 4
)
var values_NtMdt_Frame_FdScanned_Mode = map[NtMdt_Frame_FdScanned_Mode]struct{}{0: {}, 1: {}, 2: {}, 3: {}, 4: {}}
func (v NtMdt_Frame_FdScanned_Mode) isDefined() bool {
	_, ok := values_NtMdt_Frame_FdScanned_Mode[v]
	return ok
}
type NtMdt_Frame_FdScanned struct {
	Vars *NtMdt_Frame_FdScanned_Vars
	OrigFormat uint32
	Tune NtMdt_Frame_FdScanned_LiftMode
	FeedbackGain float64
	DacScale int32
	Overscan int32
	FmMode uint16
	FmXres uint16
	FmYres uint16
	Dots *NtMdt_Frame_Dots
	Image []int16
	Title *NtMdt_Title
	Xml *NtMdt_Xml
	_io *kaitai.Stream
	_root *NtMdt
	_parent *NtMdt_Frame_FrameMain
	_raw_Vars []byte
}
func NewNtMdt_Frame_FdScanned() *NtMdt_Frame_FdScanned {
	return &NtMdt_Frame_FdScanned{
	}
}

func (this NtMdt_Frame_FdScanned) IO_() *kaitai.Stream {
	return this._io
}

func (this *NtMdt_Frame_FdScanned) Read(io *kaitai.Stream, parent *NtMdt_Frame_FrameMain, root *NtMdt) (err error) {
	this._io = io
	this._parent = parent
	this._root = root

	tmp98, err := this._io.ReadBytes(int(this._parent.VarSize))
	if err != nil {
		return err
	}
	tmp98 = tmp98
	this._raw_Vars = tmp98
	_io__raw_Vars := kaitai.NewStream(bytes.NewReader(this._raw_Vars))
	tmp99 := NewNtMdt_Frame_FdScanned_Vars()
	err = tmp99.Read(_io__raw_Vars, this, this._root)
	if err != nil {
		return err
	}
	this.Vars = tmp99
	if (false) {
		tmp100, err := this._io.ReadU4le()
		if err != nil {
			return err
		}
		this.OrigFormat = uint32(tmp100)
	}
	if (false) {
		tmp101, err := this._io.ReadU4le()
		if err != nil {
			return err
		}
		this.Tune = NtMdt_Frame_FdScanned_LiftMode(tmp101)
	}
	if (false) {
		tmp102, err := this._io.ReadF8le()
		if err != nil {
			return err
		}
		this.FeedbackGain = float64(tmp102)
	}
	if (false) {
		tmp103, err := this._io.ReadS4le()
		if err != nil {
			return err
		}
		this.DacScale = int32(tmp103)
	}
	if (false) {
		tmp104, err := this._io.ReadS4le()
		if err != nil {
			return err
		}
		this.Overscan = int32(tmp104)
	}
	tmp105, err := this._io.ReadU2le()
	if err != nil {
		return err
	}
	this.FmMode = uint16(tmp105)
	tmp106, err := this._io.ReadU2le()
	if err != nil {
		return err
	}
	this.FmXres = uint16(tmp106)
	tmp107, err := this._io.ReadU2le()
	if err != nil {
		return err
	}
	this.FmYres = uint16(tmp107)
	tmp108 := NewNtMdt_Frame_Dots()
	err = tmp108.Read(this._io, this, this._root)
	if err != nil {
		return err
	}
	this.Dots = tmp108
	for i := 0; i < int(this.FmXres * this.FmYres); i++ {
		_ = i
		tmp109, err := this._io.ReadS2le()
		if err != nil {
			return err
		}
		this.Image = append(this.Image, tmp109)
	}
	tmp110 := NewNtMdt_Title()
	err = tmp110.Read(this._io, this, this._root)
	if err != nil {
		return err
	}
	this.Title = tmp110
	tmp111 := NewNtMdt_Xml()
	err = tmp111.Read(this._io, this, this._root)
	if err != nil {
		return err
	}
	this.Xml = tmp111
	return err
}

/**
 * s_oem
 */

/**
 * z_tune
 */

/**
 * s_fbg
 */

/**
 * s_s
 */

/**
 * s_xov (in %)
 */

/**
 * m_mode
 */

/**
 * m_nx
 */

/**
 * m_ny
 */
type NtMdt_Frame_FdScanned_Dot struct {
	X int16
	Y int16
	_io *kaitai.Stream
	_root *NtMdt
	_parent kaitai.Struct
}
func NewNtMdt_Frame_FdScanned_Dot() *NtMdt_Frame_FdScanned_Dot {
	return &NtMdt_Frame_FdScanned_Dot{
	}
}

func (this NtMdt_Frame_FdScanned_Dot) IO_() *kaitai.Stream {
	return this._io
}

func (this *NtMdt_Frame_FdScanned_Dot) Read(io *kaitai.Stream, parent kaitai.Struct, root *NtMdt) (err error) {
	this._io = io
	this._parent = parent
	this._root = root

	tmp112, err := this._io.ReadS2le()
	if err != nil {
		return err
	}
	this.X = int16(tmp112)
	tmp113, err := this._io.ReadS2le()
	if err != nil {
		return err
	}
	this.Y = int16(tmp113)
	return err
}
type NtMdt_Frame_FdScanned_ScanDir struct {
	Unkn uint64
	DoublePass bool
	Bottom bool
	Left bool
	Horizontal bool
	_io *kaitai.Stream
	_root *NtMdt
	_parent *NtMdt_Frame_FdScanned_Vars
}
func NewNtMdt_Frame_FdScanned_ScanDir() *NtMdt_Frame_FdScanned_ScanDir {
	return &NtMdt_Frame_FdScanned_ScanDir{
	}
}

func (this NtMdt_Frame_FdScanned_ScanDir) IO_() *kaitai.Stream {
	return this._io
}

func (this *NtMdt_Frame_FdScanned_ScanDir) Read(io *kaitai.Stream, parent *NtMdt_Frame_FdScanned_Vars, root *NtMdt) (err error) {
	this._io = io
	this._parent = parent
	this._root = root

	tmp114, err := this._io.ReadBitsIntBe(4)
	if err != nil {
		return err
	}
	this.Unkn = tmp114
	tmp115, err := this._io.ReadBitsIntBe(1)
	if err != nil {
		return err
	}
	this.DoublePass = tmp115 != 0
	tmp116, err := this._io.ReadBitsIntBe(1)
	if err != nil {
		return err
	}
	this.Bottom = tmp116 != 0
	tmp117, err := this._io.ReadBitsIntBe(1)
	if err != nil {
		return err
	}
	this.Left = tmp117 != 0
	tmp118, err := this._io.ReadBitsIntBe(1)
	if err != nil {
		return err
	}
	this.Horizontal = tmp118 != 0
	return err
}

/**
 * Bottom - 1 Top - 0
 */

/**
 * Left - 1 Right - 0
 */

/**
 * Horizontal - 1 Vertical - 0
 */
type NtMdt_Frame_FdScanned_Vars struct {
	XScale *NtMdt_Frame_AxisScale
	YScale *NtMdt_Frame_AxisScale
	ZScale *NtMdt_Frame_AxisScale
	ChannelIndex NtMdt_AdcMode
	Mode NtMdt_Frame_FdScanned_Mode
	Xres uint16
	Yres uint16
	Ndacq uint16
	StepLength float32
	Adt uint16
	AdcGainAmpLog10 uint8
	AdcIndex uint8
	InputSignalOrVersion uint8
	SubstrPlaneOrderOrPassNum uint8
	ScanDir *NtMdt_Frame_FdScanned_ScanDir
	PowerOf2 uint8
	Velocity float32
	Setpoint float32
	BiasVoltage float32
	Draw uint8
	Reserved uint8
	Xoff int32
	Yoff int32
	NlCorr uint8
	_io *kaitai.Stream
	_root *NtMdt
	_parent *NtMdt_Frame_FdScanned
}
func NewNtMdt_Frame_FdScanned_Vars() *NtMdt_Frame_FdScanned_Vars {
	return &NtMdt_Frame_FdScanned_Vars{
	}
}

func (this NtMdt_Frame_FdScanned_Vars) IO_() *kaitai.Stream {
	return this._io
}

func (this *NtMdt_Frame_FdScanned_Vars) Read(io *kaitai.Stream, parent *NtMdt_Frame_FdScanned, root *NtMdt) (err error) {
	this._io = io
	this._parent = parent
	this._root = root

	tmp119 := NewNtMdt_Frame_AxisScale()
	err = tmp119.Read(this._io, this, this._root)
	if err != nil {
		return err
	}
	this.XScale = tmp119
	tmp120 := NewNtMdt_Frame_AxisScale()
	err = tmp120.Read(this._io, this, this._root)
	if err != nil {
		return err
	}
	this.YScale = tmp120
	tmp121 := NewNtMdt_Frame_AxisScale()
	err = tmp121.Read(this._io, this, this._root)
	if err != nil {
		return err
	}
	this.ZScale = tmp121
	tmp122, err := this._io.ReadU1()
	if err != nil {
		return err
	}
	this.ChannelIndex = NtMdt_AdcMode(tmp122)
	tmp123, err := this._io.ReadU1()
	if err != nil {
		return err
	}
	this.Mode = NtMdt_Frame_FdScanned_Mode(tmp123)
	tmp124, err := this._io.ReadU2le()
	if err != nil {
		return err
	}
	this.Xres = uint16(tmp124)
	tmp125, err := this._io.ReadU2le()
	if err != nil {
		return err
	}
	this.Yres = uint16(tmp125)
	tmp126, err := this._io.ReadU2le()
	if err != nil {
		return err
	}
	this.Ndacq = uint16(tmp126)
	tmp127, err := this._io.ReadF4le()
	if err != nil {
		return err
	}
	this.StepLength = float32(tmp127)
	tmp128, err := this._io.ReadU2le()
	if err != nil {
		return err
	}
	this.Adt = uint16(tmp128)
	tmp129, err := this._io.ReadU1()
	if err != nil {
		return err
	}
	this.AdcGainAmpLog10 = tmp129
	tmp130, err := this._io.ReadU1()
	if err != nil {
		return err
	}
	this.AdcIndex = tmp130
	tmp131, err := this._io.ReadU1()
	if err != nil {
		return err
	}
	this.InputSignalOrVersion = tmp131
	tmp132, err := this._io.ReadU1()
	if err != nil {
		return err
	}
	this.SubstrPlaneOrderOrPassNum = tmp132
	tmp133 := NewNtMdt_Frame_FdScanned_ScanDir()
	err = tmp133.Read(this._io, this, this._root)
	if err != nil {
		return err
	}
	this.ScanDir = tmp133
	tmp134, err := this._io.ReadU1()
	if err != nil {
		return err
	}
	this.PowerOf2 = tmp134
	tmp135, err := this._io.ReadF4le()
	if err != nil {
		return err
	}
	this.Velocity = float32(tmp135)
	tmp136, err := this._io.ReadF4le()
	if err != nil {
		return err
	}
	this.Setpoint = float32(tmp136)
	tmp137, err := this._io.ReadF4le()
	if err != nil {
		return err
	}
	this.BiasVoltage = float32(tmp137)
	tmp138, err := this._io.ReadU1()
	if err != nil {
		return err
	}
	this.Draw = tmp138
	tmp139, err := this._io.ReadU1()
	if err != nil {
		return err
	}
	this.Reserved = tmp139
	tmp140, err := this._io.ReadS4le()
	if err != nil {
		return err
	}
	this.Xoff = int32(tmp140)
	tmp141, err := this._io.ReadS4le()
	if err != nil {
		return err
	}
	this.Yoff = int32(tmp141)
	tmp142, err := this._io.ReadU1()
	if err != nil {
		return err
	}
	this.NlCorr = tmp142
	return err
}

/**
 * s_mode
 */

/**
 * s_dev
 */

/**
 * s_nx
 */

/**
 * s_ny
 */

/**
 * Step (DAC)
 */

/**
 * s_rs in Angstrom's (Angstrom*gwy_get_gfloat_le(&p))
 */

/**
 * s_adt
 */

/**
 * s_adc_a
 */

/**
 * ADC index
 */

/**
 * MDTInputSignal smp_in; s_smp_in (for signal) s_8xx (for version)
 */

/**
 * s_spl or z_03
 */

/**
 * s_xy TODO: interpretation
 */

/**
 * s_2n (bool)
 */

/**
 * s_vel (Angstrom/second)
 */

/**
 * s_i0
 */

/**
 * s_ut
 */

/**
 * s_draw (bool)
 */

/**
 * s_x00 (in DAC quants)
 */

/**
 * s_y00 (in DAC quants)
 */

/**
 * s_cor (bool)
 */
type NtMdt_Frame_FdSpectroscopy struct {
	Vars *NtMdt_Frame_FdSpectroscopy_Vars
	FmMode uint16
	FmXres uint16
	FmYres uint16
	Dots *NtMdt_Frame_Dots
	Data []int16
	Title *NtMdt_Title
	Xml *NtMdt_Xml
	_io *kaitai.Stream
	_root *NtMdt
	_parent *NtMdt_Frame_FrameMain
	_raw_Vars []byte
}
func NewNtMdt_Frame_FdSpectroscopy() *NtMdt_Frame_FdSpectroscopy {
	return &NtMdt_Frame_FdSpectroscopy{
	}
}

func (this NtMdt_Frame_FdSpectroscopy) IO_() *kaitai.Stream {
	return this._io
}

func (this *NtMdt_Frame_FdSpectroscopy) Read(io *kaitai.Stream, parent *NtMdt_Frame_FrameMain, root *NtMdt) (err error) {
	this._io = io
	this._parent = parent
	this._root = root

	tmp143, err := this._io.ReadBytes(int(this._parent.VarSize))
	if err != nil {
		return err
	}
	tmp143 = tmp143
	this._raw_Vars = tmp143
	_io__raw_Vars := kaitai.NewStream(bytes.NewReader(this._raw_Vars))
	tmp144 := NewNtMdt_Frame_FdSpectroscopy_Vars()
	err = tmp144.Read(_io__raw_Vars, this, this._root)
	if err != nil {
		return err
	}
	this.Vars = tmp144
	tmp145, err := this._io.ReadU2le()
	if err != nil {
		return err
	}
	this.FmMode = uint16(tmp145)
	tmp146, err := this._io.ReadU2le()
	if err != nil {
		return err
	}
	this.FmXres = uint16(tmp146)
	tmp147, err := this._io.ReadU2le()
	if err != nil {
		return err
	}
	this.FmYres = uint16(tmp147)
	tmp148 := NewNtMdt_Frame_Dots()
	err = tmp148.Read(this._io, this, this._root)
	if err != nil {
		return err
	}
	this.Dots = tmp148
	for i := 0; i < int(this.FmXres * this.FmYres); i++ {
		_ = i
		tmp149, err := this._io.ReadS2le()
		if err != nil {
			return err
		}
		this.Data = append(this.Data, tmp149)
	}
	tmp150 := NewNtMdt_Title()
	err = tmp150.Read(this._io, this, this._root)
	if err != nil {
		return err
	}
	this.Title = tmp150
	tmp151 := NewNtMdt_Xml()
	err = tmp151.Read(this._io, this, this._root)
	if err != nil {
		return err
	}
	this.Xml = tmp151
	return err
}
type NtMdt_Frame_FdSpectroscopy_Vars struct {
	XScale *NtMdt_Frame_AxisScale
	YScale *NtMdt_Frame_AxisScale
	ZScale *NtMdt_Frame_AxisScale
	SpMode uint16
	SpFilter uint16
	UBegin float32
	UEnd float32
	ZUp int16
	ZDown int16
	SpAveraging uint16
	SpRepeat uint8
	SpBack uint8
	Sp4nx int16
	SpOsc uint8
	SpN4 uint8
	Sp4x0 float32
	Sp4xr float32
	Sp4u int16
	Sp4i int16
	SpNx int16
	_io *kaitai.Stream
	_root *NtMdt
	_parent *NtMdt_Frame_FdSpectroscopy
}
func NewNtMdt_Frame_FdSpectroscopy_Vars() *NtMdt_Frame_FdSpectroscopy_Vars {
	return &NtMdt_Frame_FdSpectroscopy_Vars{
	}
}

func (this NtMdt_Frame_FdSpectroscopy_Vars) IO_() *kaitai.Stream {
	return this._io
}

func (this *NtMdt_Frame_FdSpectroscopy_Vars) Read(io *kaitai.Stream, parent *NtMdt_Frame_FdSpectroscopy, root *NtMdt) (err error) {
	this._io = io
	this._parent = parent
	this._root = root

	tmp152 := NewNtMdt_Frame_AxisScale()
	err = tmp152.Read(this._io, this, this._root)
	if err != nil {
		return err
	}
	this.XScale = tmp152
	tmp153 := NewNtMdt_Frame_AxisScale()
	err = tmp153.Read(this._io, this, this._root)
	if err != nil {
		return err
	}
	this.YScale = tmp153
	tmp154 := NewNtMdt_Frame_AxisScale()
	err = tmp154.Read(this._io, this, this._root)
	if err != nil {
		return err
	}
	this.ZScale = tmp154
	tmp155, err := this._io.ReadU2le()
	if err != nil {
		return err
	}
	this.SpMode = uint16(tmp155)
	tmp156, err := this._io.ReadU2le()
	if err != nil {
		return err
	}
	this.SpFilter = uint16(tmp156)
	tmp157, err := this._io.ReadF4le()
	if err != nil {
		return err
	}
	this.UBegin = float32(tmp157)
	tmp158, err := this._io.ReadF4le()
	if err != nil {
		return err
	}
	this.UEnd = float32(tmp158)
	tmp159, err := this._io.ReadS2le()
	if err != nil {
		return err
	}
	this.ZUp = int16(tmp159)
	tmp160, err := this._io.ReadS2le()
	if err != nil {
		return err
	}
	this.ZDown = int16(tmp160)
	tmp161, err := this._io.ReadU2le()
	if err != nil {
		return err
	}
	this.SpAveraging = uint16(tmp161)
	tmp162, err := this._io.ReadU1()
	if err != nil {
		return err
	}
	this.SpRepeat = tmp162
	tmp163, err := this._io.ReadU1()
	if err != nil {
		return err
	}
	this.SpBack = tmp163
	tmp164, err := this._io.ReadS2le()
	if err != nil {
		return err
	}
	this.Sp4nx = int16(tmp164)
	tmp165, err := this._io.ReadU1()
	if err != nil {
		return err
	}
	this.SpOsc = tmp165
	tmp166, err := this._io.ReadU1()
	if err != nil {
		return err
	}
	this.SpN4 = tmp166
	tmp167, err := this._io.ReadF4le()
	if err != nil {
		return err
	}
	this.Sp4x0 = float32(tmp167)
	tmp168, err := this._io.ReadF4le()
	if err != nil {
		return err
	}
	this.Sp4xr = float32(tmp168)
	tmp169, err := this._io.ReadS2le()
	if err != nil {
		return err
	}
	this.Sp4u = int16(tmp169)
	tmp170, err := this._io.ReadS2le()
	if err != nil {
		return err
	}
	this.Sp4i = int16(tmp170)
	tmp171, err := this._io.ReadS2le()
	if err != nil {
		return err
	}
	this.SpNx = int16(tmp171)
	return err
}
type NtMdt_Frame_FrameMain struct {
	Type NtMdt_Frame_FrameType
	Version *NtMdt_Version
	DateTime *NtMdt_Frame_DateTime
	VarSize uint16
	FrameData interface{}
	_io *kaitai.Stream
	_root *NtMdt
	_parent *NtMdt_Frame
	_raw_FrameData []byte
}
func NewNtMdt_Frame_FrameMain() *NtMdt_Frame_FrameMain {
	return &NtMdt_Frame_FrameMain{
	}
}

func (this NtMdt_Frame_FrameMain) IO_() *kaitai.Stream {
	return this._io
}

func (this *NtMdt_Frame_FrameMain) Read(io *kaitai.Stream, parent *NtMdt_Frame, root *NtMdt) (err error) {
	this._io = io
	this._parent = parent
	this._root = root

	tmp172, err := this._io.ReadU2le()
	if err != nil {
		return err
	}
	this.Type = NtMdt_Frame_FrameType(tmp172)
	tmp173 := NewNtMdt_Version()
	err = tmp173.Read(this._io, this, this._root)
	if err != nil {
		return err
	}
	this.Version = tmp173
	tmp174 := NewNtMdt_Frame_DateTime()
	err = tmp174.Read(this._io, this, this._root)
	if err != nil {
		return err
	}
	this.DateTime = tmp174
	tmp175, err := this._io.ReadU2le()
	if err != nil {
		return err
	}
	this.VarSize = uint16(tmp175)
	switch (this.Type) {
	case NtMdt_Frame_FrameType__Curves:
		tmp176, err := this._io.ReadBytesFull()
		if err != nil {
			return err
		}
		tmp176 = tmp176
		this._raw_FrameData = tmp176
		_io__raw_FrameData := kaitai.NewStream(bytes.NewReader(this._raw_FrameData))
		tmp177 := NewNtMdt_Frame_FdSpectroscopy()
		err = tmp177.Read(_io__raw_FrameData, this, this._root)
		if err != nil {
			return err
		}
		this.FrameData = tmp177
	case NtMdt_Frame_FrameType__CurvesNew:
		tmp178, err := this._io.ReadBytesFull()
		if err != nil {
			return err
		}
		tmp178 = tmp178
		this._raw_FrameData = tmp178
		_io__raw_FrameData := kaitai.NewStream(bytes.NewReader(this._raw_FrameData))
		tmp179 := NewNtMdt_Frame_FdCurvesNew()
		err = tmp179.Read(_io__raw_FrameData, this, this._root)
		if err != nil {
			return err
		}
		this.FrameData = tmp179
	case NtMdt_Frame_FrameType__Mda:
		tmp180, err := this._io.ReadBytesFull()
		if err != nil {
			return err
		}
		tmp180 = tmp180
		this._raw_FrameData = tmp180
		_io__raw_FrameData := kaitai.NewStream(bytes.NewReader(this._raw_FrameData))
		tmp181 := NewNtMdt_Frame_FdMetaData()
		err = tmp181.Read(_io__raw_FrameData, this, this._root)
		if err != nil {
			return err
		}
		this.FrameData = tmp181
	case NtMdt_Frame_FrameType__Scanned:
		tmp182, err := this._io.ReadBytesFull()
		if err != nil {
			return err
		}
		tmp182 = tmp182
		this._raw_FrameData = tmp182
		_io__raw_FrameData := kaitai.NewStream(bytes.NewReader(this._raw_FrameData))
		tmp183 := NewNtMdt_Frame_FdScanned()
		err = tmp183.Read(_io__raw_FrameData, this, this._root)
		if err != nil {
			return err
		}
		this.FrameData = tmp183
	case NtMdt_Frame_FrameType__Spectroscopy:
		tmp184, err := this._io.ReadBytesFull()
		if err != nil {
			return err
		}
		tmp184 = tmp184
		this._raw_FrameData = tmp184
		_io__raw_FrameData := kaitai.NewStream(bytes.NewReader(this._raw_FrameData))
		tmp185 := NewNtMdt_Frame_FdSpectroscopy()
		err = tmp185.Read(_io__raw_FrameData, this, this._root)
		if err != nil {
			return err
		}
		this.FrameData = tmp185
	default:
		tmp186, err := this._io.ReadBytesFull()
		if err != nil {
			return err
		}
		tmp186 = tmp186
		this._raw_FrameData = tmp186
	}
	return err
}

/**
 * h_what
 */

/**
 * h_am, v6 and older only
 */

/**
 * 
 */
type NtMdt_Framez struct {
	Frames []*NtMdt_Frame
	_io *kaitai.Stream
	_root *NtMdt
	_parent *NtMdt
}
func NewNtMdt_Framez() *NtMdt_Framez {
	return &NtMdt_Framez{
	}
}

func (this NtMdt_Framez) IO_() *kaitai.Stream {
	return this._io
}

func (this *NtMdt_Framez) Read(io *kaitai.Stream, parent *NtMdt, root *NtMdt) (err error) {
	this._io = io
	this._parent = parent
	this._root = root

	for i := 0; i < int(this._root.LastFrame + 1); i++ {
		_ = i
		tmp187 := NewNtMdt_Frame()
		err = tmp187.Read(this._io, this, this._root)
		if err != nil {
			return err
		}
		this.Frames = append(this.Frames, tmp187)
	}
	return err
}
type NtMdt_Title struct {
	TitleLen uint32
	Title string
	_io *kaitai.Stream
	_root *NtMdt
	_parent kaitai.Struct
}
func NewNtMdt_Title() *NtMdt_Title {
	return &NtMdt_Title{
	}
}

func (this NtMdt_Title) IO_() *kaitai.Stream {
	return this._io
}

func (this *NtMdt_Title) Read(io *kaitai.Stream, parent kaitai.Struct, root *NtMdt) (err error) {
	this._io = io
	this._parent = parent
	this._root = root

	tmp188, err := this._io.ReadU4le()
	if err != nil {
		return err
	}
	this.TitleLen = uint32(tmp188)
	tmp189, err := this._io.ReadBytes(int(this.TitleLen))
	if err != nil {
		return err
	}
	tmp189 = tmp189
	tmp190, err := kaitai.BytesToStr(tmp189, charmap.Windows1251.NewDecoder())
	if err != nil {
		return err
	}
	this.Title = tmp190
	return err
}
type NtMdt_Uuid struct {
	Data []uint8
	_io *kaitai.Stream
	_root *NtMdt
	_parent *NtMdt_Frame_FdMetaData
}
func NewNtMdt_Uuid() *NtMdt_Uuid {
	return &NtMdt_Uuid{
	}
}

func (this NtMdt_Uuid) IO_() *kaitai.Stream {
	return this._io
}

func (this *NtMdt_Uuid) Read(io *kaitai.Stream, parent *NtMdt_Frame_FdMetaData, root *NtMdt) (err error) {
	this._io = io
	this._parent = parent
	this._root = root

	for i := 0; i < int(16); i++ {
		_ = i
		tmp191, err := this._io.ReadU1()
		if err != nil {
			return err
		}
		this.Data = append(this.Data, tmp191)
	}
	return err
}
type NtMdt_Version struct {
	Minor uint8
	Major uint8
	_io *kaitai.Stream
	_root *NtMdt
	_parent *NtMdt_Frame_FrameMain
}
func NewNtMdt_Version() *NtMdt_Version {
	return &NtMdt_Version{
	}
}

func (this NtMdt_Version) IO_() *kaitai.Stream {
	return this._io
}

func (this *NtMdt_Version) Read(io *kaitai.Stream, parent *NtMdt_Frame_FrameMain, root *NtMdt) (err error) {
	this._io = io
	this._parent = parent
	this._root = root

	tmp192, err := this._io.ReadU1()
	if err != nil {
		return err
	}
	this.Minor = tmp192
	tmp193, err := this._io.ReadU1()
	if err != nil {
		return err
	}
	this.Major = tmp193
	return err
}
type NtMdt_Xml struct {
	XmlLen uint32
	Xml string
	_io *kaitai.Stream
	_root *NtMdt
	_parent kaitai.Struct
}
func NewNtMdt_Xml() *NtMdt_Xml {
	return &NtMdt_Xml{
	}
}

func (this NtMdt_Xml) IO_() *kaitai.Stream {
	return this._io
}

func (this *NtMdt_Xml) Read(io *kaitai.Stream, parent kaitai.Struct, root *NtMdt) (err error) {
	this._io = io
	this._parent = parent
	this._root = root

	tmp194, err := this._io.ReadU4le()
	if err != nil {
		return err
	}
	this.XmlLen = uint32(tmp194)
	tmp195, err := this._io.ReadBytes(int(this.XmlLen))
	if err != nil {
		return err
	}
	tmp195 = tmp195
	tmp196, err := kaitai.BytesToStr(tmp195, unicode.UTF16(unicode.LittleEndian, unicode.IgnoreBOM).NewDecoder())
	if err != nil {
		return err
	}
	this.Xml = tmp196
	return err
}