import time

class MyTimer:

    @staticmethod
    def gMyGetTickCount():
        ts = time.time()
        return int(ts * 1000)  # Convert to milliseconds

# CTon class equivalent in Python
class CTon:
    def __init__(self):
        self.m_unET = 0
        self.m_bLastI = False
        self.m_bIn = False
        self.m_bPause = False
        self.m_bOver = True
        self.m_unPT = 0
        self.m_unStartTime = 0
        self.m_unPauseET = 0

    def GetET(self):
        if self.m_bIn:
            nET = self.m_unPT + (self.m_unStartTime - MyTimer.gMyGetTickCount())
            return max(nET, 0)
        else:
            return 0

    def SetReset(self):
        self.m_bIn = False
        self.m_bLastI = False
        self.m_bPause = False

    def SetPause(self, value):
        if self.m_bIn:
            self.m_bPause = value
        if self.m_bPause:
            self.m_unPauseET = MyTimer.gMyGetTickCount() - self.m_unStartTime

    def SetOver(self, value):
        self.m_bOver = value

    def GetStartTime(self):
        return self.m_unStartTime

    def Q(self, value_i, value_pt):
        self.m_bIn = value_i
        self.m_unPT = value_pt
        un_tick = MyTimer.gMyGetTickCount()

        if self.m_bOver and self.m_bIn:
            self.m_unStartTime = un_tick - self.m_unPT
            self.m_bOver = False

        if self.m_bPause and self.m_bIn:
            self.m_unStartTime = un_tick - self.m_unPauseET

        if self.m_bIn != self.m_bLastI:
            self.m_bLastI = self.m_bIn
            if self.m_bIn:
                self.m_unStartTime = un_tick
            self.m_bPause = False

        return self.m_bIn and (un_tick >= (self.m_unStartTime + self.m_unPT))

# CClockPulse class equivalent in Python
class CClockPulse:
    def __init__(self):
        self.m_bFirstOut = True
        self.m_bTonAOut = False
        self.m_bTonBOut = False
        self.m_cTonA = CTon()
        self.m_cTonB = CTon()

    def Q(self, value_i, run_time, stop_time):
        if self.m_bFirstOut:
            self.m_bTonAOut = self.m_cTonA.Q(not self.m_bTonBOut and value_i, run_time)
            self.m_bTonBOut = self.m_cTonB.Q(self.m_bTonAOut and value_i, stop_time)
            return not self.m_bTonAOut and value_i
        else:
            self.m_bTonAOut = self.m_cTonA.Q(not self.m_bTonBOut and value_i, stop_time)
            self.m_bTonBOut = self.m_cTonB.Q(self.m_bTonAOut and value_i, run_time)
            return self.m_bTonAOut and value_i

# CDelayOut class equivalent in Python
class CDelayOut:
    def __init__(self):
        self.m_cOutTon = CTon()
        self.m_cmWaitTon = CTon()

    def Reset(self):
        self.m_cOutTon.SetReset()
        self.m_cmWaitTon.SetReset()

    def Q(self, value_i, wait_time, out_time):
        if self.m_cmWaitTon.Q(value_i, wait_time):
            if self.m_cOutTon.Q(True, out_time):
                self.m_cOutTon.SetReset()
                self.m_cmWaitTon.SetReset()
                value_i = False
                return False
            return True
        return False

# CRisOrFall class equivalent in Python
class CRisOrFall:
    def __init__(self):
        self.m_bTemp = False

    def Q(self, value_i, ris_or_fall):
        result = False
        if value_i != self.m_bTemp:
            if ris_or_fall and value_i:  # Rising edge
                result = True
            if not ris_or_fall and not value_i:  # Falling edge
                result = True
        self.m_bTemp = value_i
        return result

# CTof class equivalent in Python
class CTof:
    def __init__(self):
        self.m_cDelayTon = CTon()
        self.m_bValue = False
        self.m_cRis = CRisOrFall()

    def SetReset(self):
        self.m_bValue = False
        self.m_cDelayTon.SetReset()

    def Q(self, value_i, delay_time):
        if self.m_cRis.Q(value_i, False):
            self.m_cDelayTon.SetReset()
            self.m_bValue = True
        if self.m_cDelayTon.Q(self.m_bValue, delay_time):
            self.m_bValue = False
            self.m_cDelayTon.SetReset()
        return value_i or self.m_bValue

# Utility function
def gGetNowTime():
    return int(time.time())