def _run_packet_mode(encoder, decoder, recoder):

    c1 = ChannelInfo()
    c2 = ChannelInfo()
    random_generator_1 = _Random()
    random_generator_2 = _Random()

    recoder_buffer = []
    dec_start = None
    dec_end = None

    # first_null = encoder.genPacket()
    # assert(first_null == '')

    while not decoder.complete():
        for x in xrange(M):
            packet = encoder.genPacket()
            assert packet != ""
            c1.num_sent += 1

            # channel 1 loss
            if random_generator_1.random() > LOSS_1:
                recoder_buffer.append(packet)
                c1.num_received += 1

            if len(recoder_buffer) is 0:
                continue

            recoder_data = "".join(recoder_buffer)
            recoded_packet = recoder.genPacket(recoder_data, len(recoder_buffer))
            c2.num_sent += 1

            # channel 2 loss
            if random_generator_2.random() > LOSS_2:

                decoder.receivePacket(recoded_packet)

                c2.num_received += 1
                if decoder.complete():
                    break

        del recoder_buffer[0 : len(recoder_buffer)]
        packet = encoder.genPacket()

        if not decoder.complete():
            assert packet is ""

    return decoder.buf, c1, c2

def _run_one_hop(encoder, decoder):
    c1 = ChannelInfo()
    random_generator_1 = _Random()

    dec_start = None
    dec_end = None

    # first_null = encoder.genPacket()
    # assert(first_null == '')

    while not decoder.complete():
        for x in xrange(M):
            packet = encoder.genPacket()
            assert packet != ""
            c1.num_sent += 1

            # channel 1 loss
            if random_generator_1.random() > LOSS_1:
                decoder.receivePacket(packet)
                c1.num_received += 1
                if decoder.complete():
                    break

        # generate a null packet
        packet = encoder.genPacket()
        if not decoder.complete():
            assert packet is ""

    return decoder.buf, c1

 def _FirstMiddlePoint( self, a, c ):
     '''
         Gets a random point within the interval where the function takes a smaller value than the limits to start iteration.
     '''
     R = _Random()
     limit = min( self.fun(a), self.fun(c) )
     while True:
         point = random.uniform( a, c )
         if self.fun(point) < limit:
             return point

def _run_batch_mode(encoder, decoder, recoder):

    c1 = ChannelInfo()
    c2 = ChannelInfo()
    random_generator_1 = _Random()
    random_generator_2 = _Random()

    recoder_buffer = []

    # first_null = encoder.genPacket()
    # assert(first_null == '')

    while True:
        # channel 1
        for i in xrange(M):
            packet = encoder.genPacket()
            assert packet is not ""
            c1.num_sent += 1
            if random_generator_1.random() >= LOSS_1:
                recoder_buffer.append(packet)
                c1.num_received += 1

        # channel 2
        if len(recoder_buffer) is 0:
            continue

        recoder_data = "".join(recoder_buffer)
        for i in xrange(M):
            recoded_packet = recoder.genPacket(recoder_data, len(recoder_buffer))
            c2.num_sent += 1
            if random_generator_2.random() >= LOSS_2:
                decoder.receivePacket(recoded_packet)
                c2.num_received += 1

                # bye bye
                if decoder.complete():
                    return decoder.buf, c1, c2

        # prepare to start a new batch
        packet = encoder.genPacket()
        assert packet is ""
        del recoder_buffer[0 : len(recoder_buffer)]

 def rng(self):
     if _os.sys.platform.startswith("java"):
         #A JVM run cannot determine or change its pid so dummy this.
         cur_pid = 1
     else:
         cur_pid = _os.getpid()
     
     if cur_pid != getattr(self, '_rng_pid', None):
         self._rng = _Random()
         self._rng_pid = cur_pid
     return self._rng

 def __init__(self):
     self.mutex = _allocate_lock()
     self.rng = _Random()
     self.normcase = _os.path.normcase

 def rng(self):
     cur_pid = _os.getpid()
     if cur_pid != getattr(self, "_rng_pid", None):
         self._rng = _Random()
         self._rng_pid = cur_pid
     return self._rng

 def __init__(self):
     self.rng = _Random()

 def rng(self) -> _Random:
     cur_pid = _os.getpid()
     if cur_pid != getattr(self, '_rng_pid', None):
         self._rng = _Random()
         self._rng_pid = cur_pid
     return self._rng