# automatically generated by the FlatBuffers compiler, do not modify

# namespace: log

import flatbuffers


# /// Logs of runs (from node start to end) of managed CF nodes .
class MNodeLog(object):
    __slots__ = ["_tab"]

    @classmethod
    def GetRootAsMNodeLog(cls, buf, offset):
        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
        x = MNodeLog()
        x.Init(buf, n + offset)
        return x

    # MNodeLog
    def Init(self, buf, pos):
        self._tab = flatbuffers.table.Table(buf, pos)

    # /// Unix time in ns when this log record was received (from CFC node clock).
    # MNodeLog

    def Timestamp(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
        if o != 0:
            return self._tab.Get(
                flatbuffers.number_types.Uint64Flags, o + self._tab.Pos
            )
        return 0

    # /// CF node ID.
    # MNodeLog

    def NodeId(self, j):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
        if o != 0:
            a = self._tab.Vector(o)
            return self._tab.Get(
                flatbuffers.number_types.Uint8Flags,
                a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1),
            )
        return 0

    # MNodeLog
    def NodeIdAsNumpy(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
        if o != 0:
            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
        return 0

    # MNodeLog
    def NodeIdLength(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
        if o != 0:
            return self._tab.VectorLen(o)
        return 0

    # /// CFC run ID (this is unique over all start-stop cycles of CFC, and constant per run).
    # MNodeLog

    def RunId(self, j):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
        if o != 0:
            a = self._tab.Vector(o)
            return self._tab.Get(
                flatbuffers.number_types.Uint8Flags,
                a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1),
            )
        return 0

    # MNodeLog
    def RunIdAsNumpy(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
        if o != 0:
            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
        return 0

    # MNodeLog
    def RunIdLength(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
        if o != 0:
            return self._tab.VectorLen(o)
        return 0

    # /// Current state of CF node.
    # MNodeLog

    def State(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
        return 0

    # /// When the state is ENDED, the end timestamp (Unix time in ns).
    # MNodeLog

    def Ended(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
        if o != 0:
            return self._tab.Get(
                flatbuffers.number_types.Uint64Flags, o + self._tab.Pos
            )
        return 0

    # /// WAMP session ID of the CF node uplink management session to this CFC instance.
    # MNodeLog

    def Session(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
        if o != 0:
            return self._tab.Get(
                flatbuffers.number_types.Uint64Flags, o + self._tab.Pos
            )
        return 0

    # /// Unix time in ns. This timestamp is from the original received event payload (from CF node clock).
    # MNodeLog

    def Sent(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
        if o != 0:
            return self._tab.Get(
                flatbuffers.number_types.Uint64Flags, o + self._tab.Pos
            )
        return 0

    # /// Sequence number as sent in the log record by the CF node (started at 0 for CF start and incremented by one on each heartbeat).
    # MNodeLog

    def Seq(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
        if o != 0:
            return self._tab.Get(
                flatbuffers.number_types.Uint64Flags, o + self._tab.Pos
            )
        return 0

    # /// Number of router workers currently running in the CF node.
    # MNodeLog

    def Routers(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
        if o != 0:
            return self._tab.Get(
                flatbuffers.number_types.Uint16Flags, o + self._tab.Pos
            )
        return 0

    # /// Number of container workers currently running in the CF node.
    # MNodeLog

    def Containers(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
        if o != 0:
            return self._tab.Get(
                flatbuffers.number_types.Uint16Flags, o + self._tab.Pos
            )
        return 0

    # /// Number of guest workers currently running in the CF node.
    # MNodeLog

    def Guests(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
        if o != 0:
            return self._tab.Get(
                flatbuffers.number_types.Uint16Flags, o + self._tab.Pos
            )
        return 0

    # /// Number of proxy workers currently running in the CF node.
    # MNodeLog

    def Proxies(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
        if o != 0:
            return self._tab.Get(
                flatbuffers.number_types.Uint16Flags, o + self._tab.Pos
            )
        return 0

    # /// Number of XBR market maker workers currently running in the CF node.
    # MNodeLog

    def Marketmakers(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
        if o != 0:
            return self._tab.Get(
                flatbuffers.number_types.Uint16Flags, o + self._tab.Pos
            )
        return 0

    # /// CF node system statistics.
    # MNodeLog

    def CpuCtxSwitches(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
        if o != 0:
            return self._tab.Get(
                flatbuffers.number_types.Uint64Flags, o + self._tab.Pos
            )
        return 0

    # MNodeLog
    def CpuFreq(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
        if o != 0:
            return self._tab.Get(
                flatbuffers.number_types.Float32Flags, o + self._tab.Pos
            )
        return 0.0

    # MNodeLog
    def CpuGuest(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(34))
        if o != 0:
            return self._tab.Get(
                flatbuffers.number_types.Float32Flags, o + self._tab.Pos
            )
        return 0.0

    # MNodeLog
    def CpuGuestNice(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36))
        if o != 0:
            return self._tab.Get(
                flatbuffers.number_types.Float32Flags, o + self._tab.Pos
            )
        return 0.0

    # MNodeLog
    def CpuIdle(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(38))
        if o != 0:
            return self._tab.Get(
                flatbuffers.number_types.Float32Flags, o + self._tab.Pos
            )
        return 0.0

    # MNodeLog
    def CpuInterrupts(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(40))
        if o != 0:
            return self._tab.Get(
                flatbuffers.number_types.Uint64Flags, o + self._tab.Pos
            )
        return 0

    # MNodeLog
    def CpuIowait(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(42))
        if o != 0:
            return self._tab.Get(
                flatbuffers.number_types.Float32Flags, o + self._tab.Pos
            )
        return 0.0

    # MNodeLog
    def CpuIrq(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(44))
        if o != 0:
            return self._tab.Get(
                flatbuffers.number_types.Float32Flags, o + self._tab.Pos
            )
        return 0.0

    # MNodeLog
    def CpuNice(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(46))
        if o != 0:
            return self._tab.Get(
                flatbuffers.number_types.Float32Flags, o + self._tab.Pos
            )
        return 0.0

    # MNodeLog
    def CpuSoftInterrupts(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(48))
        if o != 0:
            return self._tab.Get(
                flatbuffers.number_types.Uint64Flags, o + self._tab.Pos
            )
        return 0

    # MNodeLog
    def CpuSoftirq(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(50))
        if o != 0:
            return self._tab.Get(
                flatbuffers.number_types.Float32Flags, o + self._tab.Pos
            )
        return 0.0

    # MNodeLog
    def CpuSteal(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(52))
        if o != 0:
            return self._tab.Get(
                flatbuffers.number_types.Float32Flags, o + self._tab.Pos
            )
        return 0.0

    # MNodeLog
    def CpuSystem(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(54))
        if o != 0:
            return self._tab.Get(
                flatbuffers.number_types.Float32Flags, o + self._tab.Pos
            )
        return 0.0

    # MNodeLog
    def CpuUser(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(56))
        if o != 0:
            return self._tab.Get(
                flatbuffers.number_types.Float32Flags, o + self._tab.Pos
            )
        return 0.0

    # MNodeLog
    def DiskBusyTime(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(58))
        if o != 0:
            return self._tab.Get(
                flatbuffers.number_types.Uint64Flags, o + self._tab.Pos
            )
        return 0

    # MNodeLog
    def DiskReadBytes(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(60))
        if o != 0:
            return self._tab.Get(
                flatbuffers.number_types.Uint64Flags, o + self._tab.Pos
            )
        return 0

    # MNodeLog
    def DiskReadCount(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(62))
        if o != 0:
            return self._tab.Get(
                flatbuffers.number_types.Uint64Flags, o + self._tab.Pos
            )
        return 0

    # MNodeLog
    def DiskReadMergedCount(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(64))
        if o != 0:
            return self._tab.Get(
                flatbuffers.number_types.Uint64Flags, o + self._tab.Pos
            )
        return 0

    # MNodeLog
    def DiskReadTime(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(66))
        if o != 0:
            return self._tab.Get(
                flatbuffers.number_types.Uint64Flags, o + self._tab.Pos
            )
        return 0

    # MNodeLog
    def DiskWriteBytes(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(68))
        if o != 0:
            return self._tab.Get(
                flatbuffers.number_types.Uint64Flags, o + self._tab.Pos
            )
        return 0

    # MNodeLog
    def DiskWriteCount(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(70))
        if o != 0:
            return self._tab.Get(
                flatbuffers.number_types.Uint64Flags, o + self._tab.Pos
            )
        return 0

    # MNodeLog
    def DiskWriteMergedCount(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(72))
        if o != 0:
            return self._tab.Get(
                flatbuffers.number_types.Uint64Flags, o + self._tab.Pos
            )
        return 0

    # MNodeLog
    def DiskWriteTime(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(74))
        if o != 0:
            return self._tab.Get(
                flatbuffers.number_types.Uint64Flags, o + self._tab.Pos
            )
        return 0

    # MNodeLog
    def MemoryActive(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(76))
        if o != 0:
            return self._tab.Get(
                flatbuffers.number_types.Uint64Flags, o + self._tab.Pos
            )
        return 0

    # MNodeLog
    def MemoryAvailable(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(78))
        if o != 0:
            return self._tab.Get(
                flatbuffers.number_types.Uint64Flags, o + self._tab.Pos
            )
        return 0

    # MNodeLog
    def MemoryBuffers(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(80))
        if o != 0:
            return self._tab.Get(
                flatbuffers.number_types.Uint64Flags, o + self._tab.Pos
            )
        return 0

    # MNodeLog
    def MemoryCached(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(82))
        if o != 0:
            return self._tab.Get(
                flatbuffers.number_types.Uint64Flags, o + self._tab.Pos
            )
        return 0

    # MNodeLog
    def MemoryFree(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(84))
        if o != 0:
            return self._tab.Get(
                flatbuffers.number_types.Uint64Flags, o + self._tab.Pos
            )
        return 0

    # MNodeLog
    def MemoryInactive(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(86))
        if o != 0:
            return self._tab.Get(
                flatbuffers.number_types.Uint64Flags, o + self._tab.Pos
            )
        return 0

    # MNodeLog
    def MemoryPercent(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(88))
        if o != 0:
            return self._tab.Get(
                flatbuffers.number_types.Float32Flags, o + self._tab.Pos
            )
        return 0.0

    # MNodeLog
    def MemoryShared(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(90))
        if o != 0:
            return self._tab.Get(
                flatbuffers.number_types.Uint64Flags, o + self._tab.Pos
            )
        return 0

    # MNodeLog
    def MemorySlab(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(92))
        if o != 0:
            return self._tab.Get(
                flatbuffers.number_types.Uint64Flags, o + self._tab.Pos
            )
        return 0

    # MNodeLog
    def MemoryTotal(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(94))
        if o != 0:
            return self._tab.Get(
                flatbuffers.number_types.Uint64Flags, o + self._tab.Pos
            )
        return 0

    # MNodeLog
    def MemoryUsed(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(96))
        if o != 0:
            return self._tab.Get(
                flatbuffers.number_types.Uint64Flags, o + self._tab.Pos
            )
        return 0

    # MNodeLog
    def NetworkBytesRecv(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(98))
        if o != 0:
            return self._tab.Get(
                flatbuffers.number_types.Uint64Flags, o + self._tab.Pos
            )
        return 0

    # MNodeLog
    def NetworkBytesSent(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(100))
        if o != 0:
            return self._tab.Get(
                flatbuffers.number_types.Uint64Flags, o + self._tab.Pos
            )
        return 0

    # MNodeLog
    def NetworkConnectionAfInet(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
        if o != 0:
            return self._tab.Get(
                flatbuffers.number_types.Uint32Flags, o + self._tab.Pos
            )
        return 0

    # MNodeLog
    def NetworkConnectionAfInet6(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(104))
        if o != 0:
            return self._tab.Get(
                flatbuffers.number_types.Uint32Flags, o + self._tab.Pos
            )
        return 0

    # MNodeLog
    def NetworkConnectionAfUnix(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(106))
        if o != 0:
            return self._tab.Get(
                flatbuffers.number_types.Uint32Flags, o + self._tab.Pos
            )
        return 0

    # MNodeLog
    def NetworkDropin(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(108))
        if o != 0:
            return self._tab.Get(
                flatbuffers.number_types.Uint32Flags, o + self._tab.Pos
            )
        return 0

    # MNodeLog
    def NetworkDropout(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(110))
        if o != 0:
            return self._tab.Get(
                flatbuffers.number_types.Uint32Flags, o + self._tab.Pos
            )
        return 0

    # MNodeLog
    def NetworkErrin(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(112))
        if o != 0:
            return self._tab.Get(
                flatbuffers.number_types.Uint32Flags, o + self._tab.Pos
            )
        return 0

    # MNodeLog
    def NetworkErrout(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(114))
        if o != 0:
            return self._tab.Get(
                flatbuffers.number_types.Uint32Flags, o + self._tab.Pos
            )
        return 0

    # MNodeLog
    def NetworkPacketsRecv(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(116))
        if o != 0:
            return self._tab.Get(
                flatbuffers.number_types.Uint64Flags, o + self._tab.Pos
            )
        return 0

    # MNodeLog
    def NetworkPacketsSent(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(118))
        if o != 0:
            return self._tab.Get(
                flatbuffers.number_types.Uint64Flags, o + self._tab.Pos
            )
        return 0


def MNodeLogStart(builder):
    builder.StartObject(58)


def MNodeLogAddTimestamp(builder, timestamp):
    builder.PrependUint64Slot(0, timestamp, 0)


def MNodeLogAddNodeId(builder, nodeId):
    builder.PrependUOffsetTRelativeSlot(
        1, flatbuffers.number_types.UOffsetTFlags.py_type(nodeId), 0
    )


def MNodeLogStartNodeIdVector(builder, numElems):
    return builder.StartVector(1, numElems, 1)


def MNodeLogAddRunId(builder, runId):
    builder.PrependUOffsetTRelativeSlot(
        2, flatbuffers.number_types.UOffsetTFlags.py_type(runId), 0
    )


def MNodeLogStartRunIdVector(builder, numElems):
    return builder.StartVector(1, numElems, 1)


def MNodeLogAddState(builder, state):
    builder.PrependUint8Slot(3, state, 0)


def MNodeLogAddEnded(builder, ended):
    builder.PrependUint64Slot(4, ended, 0)


def MNodeLogAddSession(builder, session):
    builder.PrependUint64Slot(5, session, 0)


def MNodeLogAddSent(builder, sent):
    builder.PrependUint64Slot(6, sent, 0)


def MNodeLogAddSeq(builder, seq):
    builder.PrependUint64Slot(7, seq, 0)


def MNodeLogAddRouters(builder, routers):
    builder.PrependUint16Slot(8, routers, 0)


def MNodeLogAddContainers(builder, containers):
    builder.PrependUint16Slot(9, containers, 0)


def MNodeLogAddGuests(builder, guests):
    builder.PrependUint16Slot(10, guests, 0)


def MNodeLogAddProxies(builder, proxies):
    builder.PrependUint16Slot(11, proxies, 0)


def MNodeLogAddMarketmakers(builder, marketmakers):
    builder.PrependUint16Slot(12, marketmakers, 0)


def MNodeLogAddCpuCtxSwitches(builder, cpuCtxSwitches):
    builder.PrependUint64Slot(13, cpuCtxSwitches, 0)


def MNodeLogAddCpuFreq(builder, cpuFreq):
    builder.PrependFloat32Slot(14, cpuFreq, 0.0)


def MNodeLogAddCpuGuest(builder, cpuGuest):
    builder.PrependFloat32Slot(15, cpuGuest, 0.0)


def MNodeLogAddCpuGuestNice(builder, cpuGuestNice):
    builder.PrependFloat32Slot(16, cpuGuestNice, 0.0)


def MNodeLogAddCpuIdle(builder, cpuIdle):
    builder.PrependFloat32Slot(17, cpuIdle, 0.0)


def MNodeLogAddCpuInterrupts(builder, cpuInterrupts):
    builder.PrependUint64Slot(18, cpuInterrupts, 0)


def MNodeLogAddCpuIowait(builder, cpuIowait):
    builder.PrependFloat32Slot(19, cpuIowait, 0.0)


def MNodeLogAddCpuIrq(builder, cpuIrq):
    builder.PrependFloat32Slot(20, cpuIrq, 0.0)


def MNodeLogAddCpuNice(builder, cpuNice):
    builder.PrependFloat32Slot(21, cpuNice, 0.0)


def MNodeLogAddCpuSoftInterrupts(builder, cpuSoftInterrupts):
    builder.PrependUint64Slot(22, cpuSoftInterrupts, 0)


def MNodeLogAddCpuSoftirq(builder, cpuSoftirq):
    builder.PrependFloat32Slot(23, cpuSoftirq, 0.0)


def MNodeLogAddCpuSteal(builder, cpuSteal):
    builder.PrependFloat32Slot(24, cpuSteal, 0.0)


def MNodeLogAddCpuSystem(builder, cpuSystem):
    builder.PrependFloat32Slot(25, cpuSystem, 0.0)


def MNodeLogAddCpuUser(builder, cpuUser):
    builder.PrependFloat32Slot(26, cpuUser, 0.0)


def MNodeLogAddDiskBusyTime(builder, diskBusyTime):
    builder.PrependUint64Slot(27, diskBusyTime, 0)


def MNodeLogAddDiskReadBytes(builder, diskReadBytes):
    builder.PrependUint64Slot(28, diskReadBytes, 0)


def MNodeLogAddDiskReadCount(builder, diskReadCount):
    builder.PrependUint64Slot(29, diskReadCount, 0)


def MNodeLogAddDiskReadMergedCount(builder, diskReadMergedCount):
    builder.PrependUint64Slot(30, diskReadMergedCount, 0)


def MNodeLogAddDiskReadTime(builder, diskReadTime):
    builder.PrependUint64Slot(31, diskReadTime, 0)


def MNodeLogAddDiskWriteBytes(builder, diskWriteBytes):
    builder.PrependUint64Slot(32, diskWriteBytes, 0)


def MNodeLogAddDiskWriteCount(builder, diskWriteCount):
    builder.PrependUint64Slot(33, diskWriteCount, 0)


def MNodeLogAddDiskWriteMergedCount(builder, diskWriteMergedCount):
    builder.PrependUint64Slot(34, diskWriteMergedCount, 0)


def MNodeLogAddDiskWriteTime(builder, diskWriteTime):
    builder.PrependUint64Slot(35, diskWriteTime, 0)


def MNodeLogAddMemoryActive(builder, memoryActive):
    builder.PrependUint64Slot(36, memoryActive, 0)


def MNodeLogAddMemoryAvailable(builder, memoryAvailable):
    builder.PrependUint64Slot(37, memoryAvailable, 0)


def MNodeLogAddMemoryBuffers(builder, memoryBuffers):
    builder.PrependUint64Slot(38, memoryBuffers, 0)


def MNodeLogAddMemoryCached(builder, memoryCached):
    builder.PrependUint64Slot(39, memoryCached, 0)


def MNodeLogAddMemoryFree(builder, memoryFree):
    builder.PrependUint64Slot(40, memoryFree, 0)


def MNodeLogAddMemoryInactive(builder, memoryInactive):
    builder.PrependUint64Slot(41, memoryInactive, 0)


def MNodeLogAddMemoryPercent(builder, memoryPercent):
    builder.PrependFloat32Slot(42, memoryPercent, 0.0)


def MNodeLogAddMemoryShared(builder, memoryShared):
    builder.PrependUint64Slot(43, memoryShared, 0)


def MNodeLogAddMemorySlab(builder, memorySlab):
    builder.PrependUint64Slot(44, memorySlab, 0)


def MNodeLogAddMemoryTotal(builder, memoryTotal):
    builder.PrependUint64Slot(45, memoryTotal, 0)


def MNodeLogAddMemoryUsed(builder, memoryUsed):
    builder.PrependUint64Slot(46, memoryUsed, 0)


def MNodeLogAddNetworkBytesRecv(builder, networkBytesRecv):
    builder.PrependUint64Slot(47, networkBytesRecv, 0)


def MNodeLogAddNetworkBytesSent(builder, networkBytesSent):
    builder.PrependUint64Slot(48, networkBytesSent, 0)


def MNodeLogAddNetworkConnectionAfInet(builder, networkConnectionAfInet):
    builder.PrependUint32Slot(49, networkConnectionAfInet, 0)


def MNodeLogAddNetworkConnectionAfInet6(builder, networkConnectionAfInet6):
    builder.PrependUint32Slot(50, networkConnectionAfInet6, 0)


def MNodeLogAddNetworkConnectionAfUnix(builder, networkConnectionAfUnix):
    builder.PrependUint32Slot(51, networkConnectionAfUnix, 0)


def MNodeLogAddNetworkDropin(builder, networkDropin):
    builder.PrependUint32Slot(52, networkDropin, 0)


def MNodeLogAddNetworkDropout(builder, networkDropout):
    builder.PrependUint32Slot(53, networkDropout, 0)


def MNodeLogAddNetworkErrin(builder, networkErrin):
    builder.PrependUint32Slot(54, networkErrin, 0)


def MNodeLogAddNetworkErrout(builder, networkErrout):
    builder.PrependUint32Slot(55, networkErrout, 0)


def MNodeLogAddNetworkPacketsRecv(builder, networkPacketsRecv):
    builder.PrependUint64Slot(56, networkPacketsRecv, 0)


def MNodeLogAddNetworkPacketsSent(builder, networkPacketsSent):
    builder.PrependUint64Slot(57, networkPacketsSent, 0)


def MNodeLogEnd(builder):
    return builder.EndObject()
