mbf.py

# Generated by Haxe 3.4.7
# coding: utf-8

import math as python_lib_Math
import math as Math
from os import path as python_lib_os_Path
import inspect as python_lib_Inspect
import os as python_lib_Os
import builtins as python_lib_Builtins
import functools as python_lib_Functools
try:
    import msvcrt as python_lib_Msvcrt
except:
    pass
import random as python_lib_Random
import re as python_lib_Re
import subprocess as python_lib_Subprocess
import sys as python_lib_Sys
try:
    import termios as python_lib_Termios
except:
    pass
import time as python_lib_Time
import timeit as python_lib_Timeit
try:
    import tty as python_lib_Tty
except:
    pass


class _hx_AnonObject:
    def __init__(self, fields):
        self.__dict__ = fields


class Enum:
    _hx_class_name = "Enum"
    __slots__ = ("tag", "index", "params")
    _hx_fields = ["tag", "index", "params"]
    _hx_methods = ["__str__"]

    def __init__(self,tag,index,params):
        self.tag = tag
        self.index = index
        self.params = params

    def __str__(self):
        if (self.params is None):
            return self.tag
        else:
            _this = self.params
            return (((HxOverrides.stringOrNull(self.tag) + "(") + HxOverrides.stringOrNull(",".join([python_Boot.toString1(x1,'') for x1 in _this]))) + ")")



class Class:
    _hx_class_name = "Class"


class EReg:
    _hx_class_name = "EReg"
    __slots__ = ("pattern", "matchObj", "_hx_global")
    _hx_fields = ["pattern", "matchObj", "global"]
    _hx_methods = ["split"]

    def __init__(self,r,opt):
        self.matchObj = None
        self._hx_global = False
        options = 0
        _g1 = 0
        _g = len(opt)
        while (_g1 < _g):
            i = _g1
            _g1 = (_g1 + 1)
            c = (-1 if ((i >= len(opt))) else ord(opt[i]))
            if (c == 109):
                options = (options | python_lib_Re.M)
            if (c == 105):
                options = (options | python_lib_Re.I)
            if (c == 115):
                options = (options | python_lib_Re.S)
            if (c == 117):
                options = (options | python_lib_Re.U)
            if (c == 103):
                self._hx_global = True
        self.pattern = python_lib_Re.compile(r,options)

    def split(self,s):
        if self._hx_global:
            ret = []
            lastEnd = 0
            x = python_HaxeIterator(python_lib_Re.finditer(self.pattern,s))
            while x.hasNext():
                x1 = x.next()
                x2 = HxString.substring(s,lastEnd,x1.start())
                ret.append(x2)
                lastEnd = x1.end()
            x3 = HxString.substr(s,lastEnd,None)
            ret.append(x3)
            return ret
        else:
            self.matchObj = python_lib_Re.search(self.pattern,s)
            if (self.matchObj is None):
                return [s]
            else:
                return [HxString.substring(s,0,self.matchObj.start()), HxString.substr(s,self.matchObj.end(),None)]



class EnumValue:
    _hx_class_name = "EnumValue"


class rom_ROM:
    _hx_class_name = "rom.ROM"
    __slots__ = ("steps", "pageSize", "pages", "pageSetSize", "rom", "addr", "filename")
    _hx_fields = ["steps", "pageSize", "pages", "pageSetSize", "rom", "addr", "filename"]
    _hx_methods = ["pointerAt", "incAddr", "end", "op_add", "op_add11", "op_atbp", "op_atfc", "op_atl", "op_atpl", "op_atr", "op_bdc", "op_cend", "op_coma", "op_dc", "op_decb", "op_exbla", "op_idiv", "op_incb", "op_kta", "op_rc", "op_rot", "op_rtn0", "op_rtn1", "op_sbm", "op_sc", "op_skip", "op_ta0", "op_tabl", "op_tal", "op_tam", "op_tb", "op_tc", "op_tf1", "op_tf4", "op_tis", "op_wr", "op_ws", "op_adx", "op_exc", "op_excd", "op_exci", "op_lax", "op_lb", "op_lda", "op_rm", "op_sm", "op_t", "op_tm", "op_tmi", "op_lbl", "op_tl", "op_tml", "add", "add11", "atbp", "atfc", "atl", "atpl", "atr", "bdc", "cend", "coma", "dc", "decb", "exbla", "idiv", "incb", "kta", "rc", "rot", "rtn0", "rtn1", "sbm", "sc", "skip", "ta0", "tabl", "tal", "tam", "tb", "tc", "tf1", "tf4", "tis", "wr", "ws", "adx", "exc", "excd", "exci", "lax", "lb", "lda", "rm", "sm", "tm", "tmi", "lbl", "t", "tl", "tml"]

    def __init__(self,name):
        self.pageSetSize = 11
        self.pages = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58]
        self.pageSize = 64
        self.steps = [0, 32, 48, 56, 60, 62, 31, 47, 55, 59, 61, 30, 15, 39, 51, 57, 28, 46, 23, 43, 53, 26, 13, 6, 3, 33, 16, 40, 52, 58, 29, 14, 7, 35, 49, 24, 44, 54, 27, 45, 22, 11, 37, 18, 9, 4, 34, 17, 8, 36, 50, 25, 12, 38, 19, 41, 20, 42, 21, 10, 5, 2, 1]
        self.filename = name
        self.rom = haxe_io_Bytes.alloc(4096)
        self.addr = 0

    def pointerAt(self,a):
        page = Math.floor((a / self.pageSize))
        pageIdx = python_internal_ArrayImpl.indexOf(self.pages,page,None)
        pageSet = Math.floor((pageIdx / self.pageSetSize))
        step = (a - ((page * self.pageSize)))
        stepIdx = python_internal_ArrayImpl.indexOf(self.steps,step,None)
        return _hx_AnonObject({'pu': pageSet, 'pm': (pageIdx - ((pageSet * self.pageSetSize))), 'pl': step})

    def incAddr(self):
        ptr = self.pointerAt(self.addr)
        step = python_internal_ArrayImpl.indexOf(self.steps,ptr.pl,None)
        step = HxOverrides.mod(((step + 1)), len(self.steps))
        page = ((ptr.pu * self.pageSetSize) + ptr.pm)
        if (step == 0):
            page = HxOverrides.mod(((page + 1)), len(self.pages))
        self.addr = (((self.pages[page] if page >= 0 and page < len(self.pages) else None) * self.pageSize) + (self.steps[step] if step >= 0 and step < len(self.steps) else None))
        return self.addr

    def end(self):
        sys_io_File.saveBytes(self.filename,self.rom)

    def op_add(self):
        return [8]

    def op_add11(self):
        return [9]

    def op_atbp(self):
        return [1]

    def op_atfc(self):
        return [96]

    def op_atl(self):
        return [89]

    def op_atpl(self):
        return [3]

    def op_atr(self):
        return [97]

    def op_bdc(self):
        return [109]

    def op_cend(self):
        return [93]

    def op_coma(self):
        return [10]

    def op_dc(self):
        return [58]

    def op_decb(self):
        return [108]

    def op_exbla(self):
        return [11]

    def op_idiv(self):
        return [101]

    def op_incb(self):
        return [100]

    def op_kta(self):
        return [106]

    def op_rc(self):
        return [102]

    def op_rot(self):
        return [107]

    def op_rtn0(self):
        return [110]

    def op_rtn1(self):
        return [111]

    def op_sbm(self):
        return [2]

    def op_sc(self):
        return [103]

    def op_skip(self):
        return [0]

    def op_ta0(self):
        return [90]

    def op_tabl(self):
        return [91]

    def op_tal(self):
        return [94]

    def op_tam(self):
        return [83]

    def op_tb(self):
        return [81]

    def op_tc(self):
        return [82]

    def op_tf1(self):
        return [104]

    def op_tf4(self):
        return [105]

    def op_tis(self):
        return [88]

    def op_wr(self):
        return [98]

    def op_ws(self):
        return [99]

    def op_adx(self,x):
        return [(48 | x)]

    def op_exc(self,x):
        return [(16 | ((x & 3)))]

    def op_excd(self,x):
        return [(28 + x)]

    def op_exci(self,x):
        return [(20 + x)]

    def op_lax(self,x):
        return [(32 | x)]

    def op_lb(self,x):
        return [(64 | x)]

    def op_lda(self,x):
        return [(24 + x)]

    def op_rm(self,x):
        return [(4 + x)]

    def op_sm(self,x):
        return [(12 + x)]

    def op_t(self,x):
        return [(128 | x)]

    def op_tm(self,x):
        return [(192 + x)]

    def op_tmi(self,x):
        return [(84 + x)]

    def op_lbl(self,xy):
        return [95, xy]

    def op_tl(self,x,yz):
        return [(112 | x), yz]

    def op_tml(self,x,yz):
        return [(124 | x), yz]

    def add(self):
        _this = self.rom
        pos = self.addr
        v = python_internal_ArrayImpl._get(self.op_add(), 0)
        _this.b[pos] = (v & 255)
        self.incAddr()

    def add11(self):
        _this = self.rom
        pos = self.addr
        v = python_internal_ArrayImpl._get(self.op_add11(), 0)
        _this.b[pos] = (v & 255)
        self.incAddr()

    def atbp(self):
        _this = self.rom
        pos = self.addr
        v = python_internal_ArrayImpl._get(self.op_atbp(), 0)
        _this.b[pos] = (v & 255)
        self.incAddr()

    def atfc(self):
        _this = self.rom
        pos = self.addr
        v = python_internal_ArrayImpl._get(self.op_atfc(), 0)
        _this.b[pos] = (v & 255)
        self.incAddr()

    def atl(self):
        _this = self.rom
        pos = self.addr
        v = python_internal_ArrayImpl._get(self.op_atl(), 0)
        _this.b[pos] = (v & 255)
        self.incAddr()

    def atpl(self):
        _this = self.rom
        pos = self.addr
        v = python_internal_ArrayImpl._get(self.op_atpl(), 0)
        _this.b[pos] = (v & 255)
        self.incAddr()

    def atr(self):
        _this = self.rom
        pos = self.addr
        v = python_internal_ArrayImpl._get(self.op_atr(), 0)
        _this.b[pos] = (v & 255)
        self.incAddr()

    def bdc(self):
        _this = self.rom
        pos = self.addr
        v = python_internal_ArrayImpl._get(self.op_bdc(), 0)
        _this.b[pos] = (v & 255)
        self.incAddr()

    def cend(self):
        _this = self.rom
        pos = self.addr
        v = python_internal_ArrayImpl._get(self.op_cend(), 0)
        _this.b[pos] = (v & 255)
        self.incAddr()

    def coma(self):
        _this = self.rom
        pos = self.addr
        v = python_internal_ArrayImpl._get(self.op_coma(), 0)
        _this.b[pos] = (v & 255)
        self.incAddr()

    def dc(self):
        _this = self.rom
        pos = self.addr
        v = python_internal_ArrayImpl._get(self.op_dc(), 0)
        _this.b[pos] = (v & 255)
        self.incAddr()

    def decb(self):
        _this = self.rom
        pos = self.addr
        v = python_internal_ArrayImpl._get(self.op_decb(), 0)
        _this.b[pos] = (v & 255)
        self.incAddr()

    def exbla(self):
        _this = self.rom
        pos = self.addr
        v = python_internal_ArrayImpl._get(self.op_exbla(), 0)
        _this.b[pos] = (v & 255)
        self.incAddr()

    def idiv(self):
        _this = self.rom
        pos = self.addr
        v = python_internal_ArrayImpl._get(self.op_idiv(), 0)
        _this.b[pos] = (v & 255)
        self.incAddr()

    def incb(self):
        _this = self.rom
        pos = self.addr
        v = python_internal_ArrayImpl._get(self.op_incb(), 0)
        _this.b[pos] = (v & 255)
        self.incAddr()

    def kta(self):
        _this = self.rom
        pos = self.addr
        v = python_internal_ArrayImpl._get(self.op_kta(), 0)
        _this.b[pos] = (v & 255)
        self.incAddr()

    def rc(self):
        _this = self.rom
        pos = self.addr
        v = python_internal_ArrayImpl._get(self.op_rc(), 0)
        _this.b[pos] = (v & 255)
        self.incAddr()

    def rot(self):
        _this = self.rom
        pos = self.addr
        v = python_internal_ArrayImpl._get(self.op_rot(), 0)
        _this.b[pos] = (v & 255)
        self.incAddr()

    def rtn0(self):
        _this = self.rom
        pos = self.addr
        v = python_internal_ArrayImpl._get(self.op_rtn0(), 0)
        _this.b[pos] = (v & 255)
        self.incAddr()

    def rtn1(self):
        _this = self.rom
        pos = self.addr
        v = python_internal_ArrayImpl._get(self.op_rtn1(), 0)
        _this.b[pos] = (v & 255)
        self.incAddr()

    def sbm(self):
        _this = self.rom
        pos = self.addr
        v = python_internal_ArrayImpl._get(self.op_sbm(), 0)
        _this.b[pos] = (v & 255)
        self.incAddr()

    def sc(self):
        _this = self.rom
        pos = self.addr
        v = python_internal_ArrayImpl._get(self.op_sc(), 0)
        _this.b[pos] = (v & 255)
        self.incAddr()

    def skip(self):
        _this = self.rom
        pos = self.addr
        v = python_internal_ArrayImpl._get(self.op_skip(), 0)
        _this.b[pos] = (v & 255)
        self.incAddr()

    def ta0(self):
        _this = self.rom
        pos = self.addr
        v = python_internal_ArrayImpl._get(self.op_ta0(), 0)
        _this.b[pos] = (v & 255)
        self.incAddr()

    def tabl(self):
        _this = self.rom
        pos = self.addr
        v = python_internal_ArrayImpl._get(self.op_tabl(), 0)
        _this.b[pos] = (v & 255)
        self.incAddr()

    def tal(self):
        _this = self.rom
        pos = self.addr
        v = python_internal_ArrayImpl._get(self.op_tal(), 0)
        _this.b[pos] = (v & 255)
        self.incAddr()

    def tam(self):
        _this = self.rom
        pos = self.addr
        v = python_internal_ArrayImpl._get(self.op_tam(), 0)
        _this.b[pos] = (v & 255)
        self.incAddr()

    def tb(self):
        _this = self.rom
        pos = self.addr
        v = python_internal_ArrayImpl._get(self.op_tb(), 0)
        _this.b[pos] = (v & 255)
        self.incAddr()

    def tc(self):
        _this = self.rom
        pos = self.addr
        v = python_internal_ArrayImpl._get(self.op_tc(), 0)
        _this.b[pos] = (v & 255)
        self.incAddr()

    def tf1(self):
        _this = self.rom
        pos = self.addr
        v = python_internal_ArrayImpl._get(self.op_tf1(), 0)
        _this.b[pos] = (v & 255)
        self.incAddr()

    def tf4(self):
        _this = self.rom
        pos = self.addr
        v = python_internal_ArrayImpl._get(self.op_tf4(), 0)
        _this.b[pos] = (v & 255)
        self.incAddr()

    def tis(self):
        _this = self.rom
        pos = self.addr
        v = python_internal_ArrayImpl._get(self.op_tis(), 0)
        _this.b[pos] = (v & 255)
        self.incAddr()

    def wr(self):
        _this = self.rom
        pos = self.addr
        v = python_internal_ArrayImpl._get(self.op_wr(), 0)
        _this.b[pos] = (v & 255)
        self.incAddr()

    def ws(self):
        _this = self.rom
        pos = self.addr
        v = python_internal_ArrayImpl._get(self.op_ws(), 0)
        _this.b[pos] = (v & 255)
        self.incAddr()

    def adx(self,x):
        _this = self.rom
        pos = self.addr
        v = python_internal_ArrayImpl._get(self.op_adx(x), 0)
        _this.b[pos] = (v & 255)
        self.incAddr()

    def exc(self,x):
        _this = self.rom
        pos = self.addr
        v = python_internal_ArrayImpl._get(self.op_exc(x), 0)
        _this.b[pos] = (v & 255)
        self.incAddr()

    def excd(self,x):
        _this = self.rom
        pos = self.addr
        v = python_internal_ArrayImpl._get(self.op_excd(x), 0)
        _this.b[pos] = (v & 255)
        self.incAddr()

    def exci(self,x):
        _this = self.rom
        pos = self.addr
        v = python_internal_ArrayImpl._get(self.op_exci(x), 0)
        _this.b[pos] = (v & 255)
        self.incAddr()

    def lax(self,x):
        _this = self.rom
        pos = self.addr
        v = python_internal_ArrayImpl._get(self.op_lax(x), 0)
        _this.b[pos] = (v & 255)
        self.incAddr()

    def lb(self,x):
        _this = self.rom
        pos = self.addr
        v = python_internal_ArrayImpl._get(self.op_lb(x), 0)
        _this.b[pos] = (v & 255)
        self.incAddr()

    def lda(self,x):
        _this = self.rom
        pos = self.addr
        v = python_internal_ArrayImpl._get(self.op_lda(x), 0)
        _this.b[pos] = (v & 255)
        self.incAddr()

    def rm(self,x):
        _this = self.rom
        pos = self.addr
        v = python_internal_ArrayImpl._get(self.op_rm(x), 0)
        _this.b[pos] = (v & 255)
        self.incAddr()

    def sm(self,x):
        _this = self.rom
        pos = self.addr
        v = python_internal_ArrayImpl._get(self.op_sm(x), 0)
        _this.b[pos] = (v & 255)
        self.incAddr()

    def tm(self,x):
        _this = self.rom
        pos = self.addr
        v = python_internal_ArrayImpl._get(self.op_tm(x), 0)
        _this.b[pos] = (v & 255)
        self.incAddr()

    def tmi(self,x):
        _this = self.rom
        pos = self.addr
        v = python_internal_ArrayImpl._get(self.op_tmi(x), 0)
        _this.b[pos] = (v & 255)
        self.incAddr()

    def lbl(self,xy):
        ops = self.op_lbl(xy)
        self.rom.b[self.addr] = ((ops[0] if 0 < len(ops) else None) & 255)
        self.incAddr()
        self.rom.b[self.addr] = ((ops[1] if 1 < len(ops) else None) & 255)
        self.incAddr()

    def t(self,a):
        ptr = self.pointerAt(a)
        _this = self.rom
        pos = self.addr
        v = python_internal_ArrayImpl._get(self.op_t(ptr.pl), 0)
        _this.b[pos] = (v & 255)
        self.incAddr()

    def tl(self,a):
        ptr = self.pointerAt(a)
        ops = self.op_tl(ptr.pm,((ptr.pu << 6) | ptr.pl))
        self.rom.b[self.addr] = ((ops[0] if 0 < len(ops) else None) & 255)
        self.incAddr()
        self.rom.b[self.addr] = ((ops[1] if 1 < len(ops) else None) & 255)
        self.incAddr()

    def tml(self,a):
        ptr = self.pointerAt(a)
        ops = self.op_tml(ptr.pm,((ptr.pu << 6) | ptr.pl))
        self.rom.b[self.addr] = ((ops[0] if 0 < len(ops) else None) & 255)
        self.incAddr()
        self.rom.b[self.addr] = ((ops[1] if 1 < len(ops) else None) & 255)
        self.incAddr()



class MBF(rom_ROM):
    _hx_class_name = "MBF"
    __slots__ = ("env",)
    _hx_fields = ["env"]
    _hx_methods = ["processLine", "num"]
    _hx_statics = ["main"]
    _hx_interfaces = []
    _hx_super = rom_ROM


    def __init__(self,raw,romName):
        self.env = None
        super().__init__(romName)
        out = Sys.stdout()
        out.writeString((("Creating " + ("null" if romName is None else romName)) + ".\n"))
        out.writeString("Initializing environment.\n")
        self.env = haxe_ds_StringMap()
        out.writeString("Stripping comments.\n")
        _this = raw.lower()
        wComments = _this.split("\n")
        woComments = []
        _g = 0
        while (_g < len(wComments)):
            line = (wComments[_g] if _g >= 0 and _g < len(wComments) else None)
            _g = (_g + 1)
            x = HxOverrides.arrayGet(line.split(";"), 0)
            woComments.append(x)
        out.writeString("Splitting columns.\n")
        asm = []
        ws = EReg("[ \t]+","g")
        _g1 = 0
        while (_g1 < len(woComments)):
            line1 = (woComments[_g1] if _g1 >= 0 and _g1 < len(woComments) else None)
            _g1 = (_g1 + 1)
            x1 = ws.split(line1)
            asm.append(x1)
        out.writeString("Beginning first parsing pass.\n")
        out.writeString("Processing line ")
        lineNo = 1
        _g2 = 0
        while (_g2 < len(asm)):
            line2 = (asm[_g2] if _g2 >= 0 and _g2 < len(asm) else None)
            _g2 = (_g2 + 1)
            self.processLine(line2)
            tmp = lineNo
            lineNo = (lineNo + 1)
            out.writeString(((" " + Std.string(tmp)) + " "))
            out.flush()
        out.writeString(".\n")
        out.writeString("Resetting rom.\n")
        self.rom.fill(0,4096,0)
        out.writeString("Beginning second parsing pass.\n")
        out.writeString("Processing line ")
        lineNo = 1
        _g3 = 0
        while (_g3 < len(asm)):
            line3 = (asm[_g3] if _g3 >= 0 and _g3 < len(asm) else None)
            _g3 = (_g3 + 1)
            self.processLine(line3)
            tmp1 = lineNo
            lineNo = (lineNo + 1)
            out.writeString(((" " + Std.string(tmp1)) + " "))
            out.flush()
        out.writeString(".\n")
        out.writeString("Finalizing rom.\n")
        self.end()
        out.close()

    def processLine(self,line):
        if ((len(line) == 1) and (((line[0] if 0 < len(line) else None) == ""))):
            return
        if ((len(line) > 1) and (((line[0] if 0 < len(line) else None) == "org"))):
            self.addr = self.num((line[1] if 1 < len(line) else None))
            return
        if ((len(line) > 2) and (((line[1] if 1 < len(line) else None) == "equ"))):
            this1 = self.env
            v = self.num((line[2] if 2 < len(line) else None))
            this1.h[(line[0] if 0 < len(line) else None)] = v
            return
        if ((len(line) > 2) and (((line[1] if 1 < len(line) else None) == ".word"))):
            _this = self.rom
            pos = self.addr
            v1 = self.num((line[2] if 2 < len(line) else None))
            _this.b[pos] = (v1 & 255)
            self.incAddr()
            return
        if ((line[0] if 0 < len(line) else None) != ""):
            v2 = self.addr
            self.env.h[(line[0] if 0 < len(line) else None)] = v2
            if ((len(line) > 1) and (((line[1] if 1 < len(line) else None) == ""))):
                return
        if (len(line) < 2):
            return
        operand = 0
        if (len(line) > 2):
            operand = self.num((line[2] if 2 < len(line) else None))
        opcode = (line[1] if 1 < len(line) else None)
        opcode1 = opcode
        _hx_local_0 = len(opcode1)
        if (_hx_local_0 == 1):
            if (opcode1 == "t"):
                self.t(operand)
            else:
                self.skip()
        elif (_hx_local_0 == 5):
            if (opcode1 == "add11"):
                self.add11()
            elif (opcode1 == "exbla"):
                self.exbla()
            else:
                self.skip()
        elif (_hx_local_0 == 4):
            if (opcode1 == "atbp"):
                self.atbp()
            elif (opcode1 == "atfc"):
                self.atfc()
            elif (opcode1 == "atpl"):
                self.atpl()
            elif (opcode1 == "cend"):
                self.cend()
            elif (opcode1 == "coma"):
                self.coma()
            elif (opcode1 == "decb"):
                self.decb()
            elif (opcode1 == "excd"):
                self.excd(operand)
            elif (opcode1 == "exci"):
                self.exci(operand)
            elif (opcode1 == "idiv"):
                self.idiv()
            elif (opcode1 == "incb"):
                self.incb()
            elif (opcode1 == "rtn0"):
                self.rtn0()
            elif (opcode1 == "rtn1"):
                self.rtn1()
            elif (opcode1 == "tabl"):
                self.tabl()
            else:
                self.skip()
        elif (_hx_local_0 == 3):
            if (opcode1 == "add"):
                self.add()
            elif (opcode1 == "adx"):
                self.adx(operand)
            elif (opcode1 == "atl"):
                self.atl()
            elif (opcode1 == "atr"):
                self.atr()
            elif (opcode1 == "bdc"):
                self.bdc()
            elif (opcode1 == "exc"):
                self.exc(operand)
            elif (opcode1 == "kta"):
                self.kta()
            elif (opcode1 == "lax"):
                self.lax(operand)
            elif (opcode1 == "lbl"):
                self.lbl(operand)
            elif (opcode1 == "lda"):
                self.lda(operand)
            elif (opcode1 == "rot"):
                self.rot()
            elif (opcode1 == "sbm"):
                self.sbm()
            elif (opcode1 == "ta0"):
                self.ta0()
            elif (opcode1 == "tal"):
                self.tal()
            elif (opcode1 == "tam"):
                self.tam()
            elif (opcode1 == "tf1"):
                self.tf1()
            elif (opcode1 == "tf4"):
                self.tf4()
            elif (opcode1 == "tis"):
                self.tis()
            elif (opcode1 == "tmi"):
                self.tmi(operand)
            elif (opcode1 == "tml"):
                self.tml(operand)
            else:
                self.skip()
        elif (_hx_local_0 == 2):
            if (opcode1 == "dc"):
                self.dc()
            elif (opcode1 == "lb"):
                self.lb(operand)
            elif (opcode1 == "rc"):
                self.rc()
            elif (opcode1 == "rm"):
                self.rm(operand)
            elif (opcode1 == "sc"):
                self.sc()
            elif (opcode1 == "sm"):
                self.sm(operand)
            elif (opcode1 == "tb"):
                self.tb()
            elif (opcode1 == "tc"):
                self.tc()
            elif (opcode1 == "tl"):
                self.tl(operand)
            elif (opcode1 == "tm"):
                self.tm(operand)
            elif (opcode1 == "wr"):
                self.wr()
            elif (opcode1 == "ws"):
                self.ws()
            else:
                self.skip()
        else:
            self.skip()

    def num(self,_hx_str):
        val = 0
        if ((("" if ((0 >= len(_hx_str))) else _hx_str[0])) != "$"):
            val = self.env.h.get(_hx_str,None)
            if (val is not None):
                return val
            return 0
        _hx_str = HxOverrides.arrayGet(_hx_str.split("$"), 1)
        val1 = 0
        _g1 = 0
        _g = len(_hx_str)
        while (_g1 < _g):
            i = _g1
            _g1 = (_g1 + 1)
            val1 = ((val1 * 16) + ((((HxString.charCodeAt(_hx_str,i) - 97) + 10) if ((HxString.charCodeAt(_hx_str,i) >= 97)) else (HxString.charCodeAt(_hx_str,i) - 48))))
        return val1

    @staticmethod
    def main():
        if (len(Sys.args()) != 2):
            out = Sys.stdout()
            out.writeString("needed arguments:\n    input.asm output.bin        #assemble .asm into .bin\n")
            out.close()
            Sys.exit(1)
        try:
            asm = sys_io_File.read(python_internal_ArrayImpl._get(Sys.args(), 0)).readAll().toString()
            mbf = MBF(asm,python_internal_ArrayImpl._get(Sys.args(), 1))
        except Exception as _hx_e:
            _hx_e1 = _hx_e.val if isinstance(_hx_e, _HxException) else _hx_e
            e = _hx_e1
            err = Sys.stderr()
            try:
                def _hx_local_0():
                    _hx_local_0 = e
                    if Std._hx_is(_hx_local_0,str):
                        _hx_local_0
                    else:
                        raise _HxException("Class cast error")
                    return _hx_local_0
                msg = _hx_local_0()
                err.writeString((("Error:\n    " + ("null" if msg is None else msg)) + "\n"))
            except Exception as _hx_e:
                _hx_e1 = _hx_e.val if isinstance(_hx_e, _HxException) else _hx_e
                e1 = _hx_e1
                err.writeString("Unknown error.\n")
            err.close()
            Sys.exit(1)
        Sys.exit(0)



class Reflect:
    _hx_class_name = "Reflect"
    __slots__ = ()
    _hx_statics = ["field"]

    @staticmethod
    def field(o,field):
        return python_Boot.field(o,field)


class Std:
    _hx_class_name = "Std"
    __slots__ = ()
    _hx_statics = ["is", "string"]

    @staticmethod
    def _hx_is(v,t):
        if ((v is None) and ((t is None))):
            return False
        if (t is None):
            return False
        if (t == Dynamic):
            return True
        isBool = isinstance(v,bool)
        if ((t == Bool) and isBool):
            return True
        if ((((not isBool) and (not (t == Bool))) and (t == Int)) and isinstance(v,int)):
            return True
        vIsFloat = isinstance(v,float)
        tmp = None
        tmp1 = None
        tmp2 = None
        tmp3 = None
        if (((not isBool) and vIsFloat) and (t == Int)):
            f = v
            if ((f != Math.POSITIVE_INFINITY) and ((f != Math.NEGATIVE_INFINITY))):
                tmp3 = (not python_lib_Math.isnan(f))
            else:
                tmp3 = False
        else:
            tmp3 = False
        if tmp3:
            tmp4 = None
            try:
                tmp4 = int(v)
            except Exception as _hx_e:
                _hx_e1 = _hx_e.val if isinstance(_hx_e, _HxException) else _hx_e
                e = _hx_e1
                tmp4 = None
            tmp2 = (v == tmp4)
        else:
            tmp2 = False
        if tmp2:
            tmp1 = (v <= 2147483647)
        else:
            tmp1 = False
        if tmp1:
            tmp = (v >= -2147483648)
        else:
            tmp = False
        if tmp:
            return True
        if (((not isBool) and (t == Float)) and isinstance(v,(float, int))):
            return True
        if (t == str):
            return isinstance(v,str)
        isEnumType = (t == Enum)
        if ((isEnumType and python_lib_Inspect.isclass(v)) and hasattr(v,"_hx_constructs")):
            return True
        if isEnumType:
            return False
        isClassType = (t == Class)
        if ((((isClassType and (not isinstance(v,Enum))) and python_lib_Inspect.isclass(v)) and hasattr(v,"_hx_class_name")) and (not hasattr(v,"_hx_constructs"))):
            return True
        if isClassType:
            return False
        tmp5 = None
        try:
            tmp5 = isinstance(v,t)
        except Exception as _hx_e:
            _hx_e1 = _hx_e.val if isinstance(_hx_e, _HxException) else _hx_e
            e1 = _hx_e1
            tmp5 = False
        if tmp5:
            return True
        if python_lib_Inspect.isclass(t):
            loop = None
            def _hx_local_1(intf):
                f1 = (intf._hx_interfaces if (hasattr(intf,"_hx_interfaces")) else [])
                if (f1 is not None):
                    _g = 0
                    while (_g < len(f1)):
                        i = (f1[_g] if _g >= 0 and _g < len(f1) else None)
                        _g = (_g + 1)
                        if HxOverrides.eq(i,t):
                            return True
                        else:
                            l = loop(i)
                            if l:
                                return True
                    return False
                else:
                    return False
            loop = _hx_local_1
            loop1 = loop
            currentClass = v.__class__
            while (currentClass is not None):
                if loop1(currentClass):
                    return True
                currentClass = python_Boot.getSuperClass(currentClass)
            return False
        else:
            return False

    @staticmethod
    def string(s):
        return python_Boot.toString1(s,"")


class Float:
    _hx_class_name = "Float"


class Int:
    _hx_class_name = "Int"


class Bool:
    _hx_class_name = "Bool"


class Dynamic:
    _hx_class_name = "Dynamic"


class StringTools:
    _hx_class_name = "StringTools"
    __slots__ = ()
    _hx_statics = ["startsWith"]

    @staticmethod
    def startsWith(s,start):
        if (len(s) >= len(start)):
            return (HxString.substr(s,0,len(start)) == start)
        else:
            return False


class sys_FileSystem:
    _hx_class_name = "sys.FileSystem"
    __slots__ = ()
    _hx_statics = ["fullPath"]

    @staticmethod
    def fullPath(relPath):
        return python_lib_os_Path.realpath(relPath)


class haxe_IMap:
    _hx_class_name = "haxe.IMap"
    __slots__ = ()


class haxe_ds_StringMap:
    _hx_class_name = "haxe.ds.StringMap"
    __slots__ = ("h",)
    _hx_fields = ["h"]
    _hx_interfaces = [haxe_IMap]

    def __init__(self):
        self.h = dict()



class python_HaxeIterator:
    _hx_class_name = "python.HaxeIterator"
    __slots__ = ("it", "x", "has", "checked")
    _hx_fields = ["it", "x", "has", "checked"]
    _hx_methods = ["next", "hasNext"]

    def __init__(self,it):
        self.checked = False
        self.has = False
        self.x = None
        self.it = it

    def next(self):
        if (not self.checked):
            self.hasNext()
        self.checked = False
        return self.x

    def hasNext(self):
        if (not self.checked):
            try:
                self.x = self.it.__next__()
                self.has = True
            except Exception as _hx_e:
                _hx_e1 = _hx_e.val if isinstance(_hx_e, _HxException) else _hx_e
                if isinstance(_hx_e1, StopIteration):
                    s = _hx_e1
                    self.has = False
                    self.x = None
                else:
                    raise _hx_e
            self.checked = True
        return self.has



class Sys:
    _hx_class_name = "Sys"
    __slots__ = ()
    _hx_statics = ["environ", "time", "exit", "print", "println", "args", "getEnv", "putEnv", "environment", "sleep", "setTimeLocale", "getCwd", "setCwd", "systemName", "command", "cpuTime", "executablePath", "_programPath", "programPath", "getChar", "stdin", "stdout", "stderr"]

    @staticmethod
    def time():
        return python_lib_Time.time()

    @staticmethod
    def exit(code):
        python_lib_Sys.exit(code)

    @staticmethod
    def print(v):
        python_Lib.print(v)

    @staticmethod
    def println(v):
        python_Lib.println(v)

    @staticmethod
    def args():
        argv = python_lib_Sys.argv
        return argv[1:None]

    @staticmethod
    def getEnv(s):
        return Sys.environ.h.get(s,None)

    @staticmethod
    def putEnv(s,v):
        python_lib_Os.putenv(s,v)
        Sys.environ.h[s] = v

    @staticmethod
    def environment():
        return Sys.environ

    @staticmethod
    def sleep(seconds):
        python_lib_Time.sleep(seconds)

    @staticmethod
    def setTimeLocale(loc):
        return False

    @staticmethod
    def getCwd():
        return python_lib_Os.getcwd()

    @staticmethod
    def setCwd(s):
        python_lib_Os.chdir(s)

    @staticmethod
    def systemName():
        _g = python_lib_Sys.platform
        x = _g
        if StringTools.startsWith(x,"linux"):
            return "Linux"
        else:
            _g1 = _g
            _hx_local_0 = len(_g1)
            if (_hx_local_0 == 5):
                if (_g1 == "win32"):
                    return "Windows"
                else:
                    raise _HxException("not supported platform")
            elif (_hx_local_0 == 6):
                if (_g1 == "cygwin"):
                    return "Windows"
                elif (_g1 == "darwin"):
                    return "Mac"
                else:
                    raise _HxException("not supported platform")
            else:
                raise _HxException("not supported platform")

    @staticmethod
    def command(cmd,args = None):
        if (args is None):
            return python_lib_Subprocess.call(cmd,**python__KwArgs_KwArgs_Impl_.fromT(_hx_AnonObject({'shell': True})))
        else:
            return python_lib_Subprocess.call(([cmd] + args))

    @staticmethod
    def cpuTime():
        return python_lib_Timeit.default_timer()

    @staticmethod
    def executablePath():
        return python_internal_ArrayImpl._get(python_lib_Sys.argv, 0)

    @staticmethod
    def programPath():
        return Sys._programPath

    @staticmethod
    def getChar(echo):
        ch = None
        _g = Sys.systemName()
        _g1 = _g
        _hx_local_0 = len(_g1)
        if (_hx_local_0 == 5):
            if (_g1 == "Linux"):
                fd = python_lib_Sys.stdin.fileno()
                old = python_lib_Termios.tcgetattr(fd)
                a1 = fd
                a2 = python_lib_Termios.TCSADRAIN
                a3 = old
                def _hx_local_1():
                    python_lib_Termios.tcsetattr(a1,a2,a3)
                restore = _hx_local_1
                try:
                    python_lib_Tty.setraw(fd)
                    x = python_lib_Sys.stdin.read(1)
                    restore()
                    ch = HxString.charCodeAt(x,0)
                except Exception as _hx_e:
                    _hx_e1 = _hx_e.val if isinstance(_hx_e, _HxException) else _hx_e
                    e = _hx_e1
                    restore()
                    raise _HxException(e)
            else:
                x1 = _g
                raise _HxException((("platform " + ("null" if x1 is None else x1)) + " not supported"))
        elif (_hx_local_0 == 3):
            if (_g1 == "Mac"):
                fd = python_lib_Sys.stdin.fileno()
                old = python_lib_Termios.tcgetattr(fd)
                a1 = fd
                a2 = python_lib_Termios.TCSADRAIN
                a3 = old
                def _hx_local_2():
                    python_lib_Termios.tcsetattr(a1,a2,a3)
                restore = _hx_local_2
                try:
                    python_lib_Tty.setraw(fd)
                    x = python_lib_Sys.stdin.read(1)
                    restore()
                    ch = HxString.charCodeAt(x,0)
                except Exception as _hx_e:
                    _hx_e1 = _hx_e.val if isinstance(_hx_e, _HxException) else _hx_e
                    e = _hx_e1
                    restore()
                    raise _HxException(e)
            else:
                x1 = _g
                raise _HxException((("platform " + ("null" if x1 is None else x1)) + " not supported"))
        elif (_hx_local_0 == 7):
            if (_g1 == "Windows"):
                ch = HxString.charCodeAt(python_lib_Msvcrt.getch().decode("utf-8"),0)
            else:
                x1 = _g
                raise _HxException((("platform " + ("null" if x1 is None else x1)) + " not supported"))
        else:
            x1 = _g
            raise _HxException((("platform " + ("null" if x1 is None else x1)) + " not supported"))
        if echo:
            python_Lib.print("".join(map(chr,[ch])))
        return ch

    @staticmethod
    def stdin():
        return python_io_IoTools.createFileInputFromText(python_lib_Sys.stdin)

    @staticmethod
    def stdout():
        return python_io_IoTools.createFileOutputFromText(python_lib_Sys.stdout)

    @staticmethod
    def stderr():
        return python_io_IoTools.createFileOutputFromText(python_lib_Sys.stderr)


class haxe_io_Bytes:
    _hx_class_name = "haxe.io.Bytes"
    __slots__ = ("length", "b")
    _hx_fields = ["length", "b"]
    _hx_methods = ["blit", "fill", "getString", "toString"]
    _hx_statics = ["alloc", "ofString", "ofData"]

    def __init__(self,length,b):
        self.length = length
        self.b = b

    def blit(self,pos,src,srcpos,_hx_len):
        if (((((pos < 0) or ((srcpos < 0))) or ((_hx_len < 0))) or (((pos + _hx_len) > self.length))) or (((srcpos + _hx_len) > src.length))):
            raise _HxException(haxe_io_Error.OutsideBounds)
        self.b[pos:pos+_hx_len] = src.b[srcpos:srcpos+_hx_len]

    def fill(self,pos,_hx_len,value):
        _g1 = 0
        _g = _hx_len
        while (_g1 < _g):
            i = _g1
            _g1 = (_g1 + 1)
            pos1 = pos
            pos = (pos + 1)
            self.b[pos1] = (value & 255)

    def getString(self,pos,_hx_len):
        if (((pos < 0) or ((_hx_len < 0))) or (((pos + _hx_len) > self.length))):
            raise _HxException(haxe_io_Error.OutsideBounds)
        return self.b[pos:pos+_hx_len].decode('UTF-8','replace')

    def toString(self):
        return self.getString(0,self.length)

    @staticmethod
    def alloc(length):
        return haxe_io_Bytes(length,bytearray(length))

    @staticmethod
    def ofString(s):
        b = bytearray(s,"UTF-8")
        return haxe_io_Bytes(len(b),b)

    @staticmethod
    def ofData(b):
        return haxe_io_Bytes(len(b),b)



class haxe_io_BytesBuffer:
    _hx_class_name = "haxe.io.BytesBuffer"
    __slots__ = ("b",)
    _hx_fields = ["b"]
    _hx_methods = ["getBytes"]

    def __init__(self):
        self.b = list()

    def getBytes(self):
        buf = bytearray(self.b)
        _hx_bytes = haxe_io_Bytes(len(buf),buf)
        self.b = None
        return _hx_bytes



class haxe_io_Input:
    _hx_class_name = "haxe.io.Input"
    __slots__ = ("bigEndian",)
    _hx_fields = ["bigEndian"]
    _hx_methods = ["readByte", "readBytes", "set_bigEndian", "readAll"]

    def readByte(self):
        raise _HxException("Not implemented")

    def readBytes(self,s,pos,_hx_len):
        k = _hx_len
        b = s.b
        if (((pos < 0) or ((_hx_len < 0))) or (((pos + _hx_len) > s.length))):
            raise _HxException(haxe_io_Error.OutsideBounds)
        try:
            while (k > 0):
                b[pos] = self.readByte()
                pos = (pos + 1)
                k = (k - 1)
        except Exception as _hx_e:
            _hx_e1 = _hx_e.val if isinstance(_hx_e, _HxException) else _hx_e
            if isinstance(_hx_e1, haxe_io_Eof):
                    pass
            else:
                raise _hx_e
        return (_hx_len - k)

    def set_bigEndian(self,b):
        self.bigEndian = b
        return b

    def readAll(self,bufsize = None):
        if (bufsize is None):
            bufsize = 16384
        buf = haxe_io_Bytes.alloc(bufsize)
        total = haxe_io_BytesBuffer()
        try:
            while True:
                _hx_len = self.readBytes(buf,0,bufsize)
                if (_hx_len == 0):
                    raise _HxException(haxe_io_Error.Blocked)
                if ((_hx_len < 0) or ((_hx_len > buf.length))):
                    raise _HxException(haxe_io_Error.OutsideBounds)
                b1 = total.b
                b2 = buf.b
                _g1 = 0
                _g = _hx_len
                while (_g1 < _g):
                    i = _g1
                    _g1 = (_g1 + 1)
                    _this = total.b
                    _this.append(b2[i])
        except Exception as _hx_e:
            _hx_e1 = _hx_e.val if isinstance(_hx_e, _HxException) else _hx_e
            if isinstance(_hx_e1, haxe_io_Eof):
                    pass
            else:
                raise _hx_e
        return total.getBytes()



class haxe_io_Eof:
    _hx_class_name = "haxe.io.Eof"
    __slots__ = ()
    _hx_methods = ["toString"]

    def __init__(self):
        pass

    def toString(self):
        return "Eof"


class haxe_io_Error(Enum):
    __slots__ = ()
    _hx_class_name = "haxe.io.Error"
    _hx_constructs = ["Blocked", "Overflow", "OutsideBounds", "Custom"]

    @staticmethod
    def Custom(e):
        return haxe_io_Error("Custom", 3, [e])
haxe_io_Error.Blocked = haxe_io_Error("Blocked", 0, list())
haxe_io_Error.Overflow = haxe_io_Error("Overflow", 1, list())
haxe_io_Error.OutsideBounds = haxe_io_Error("OutsideBounds", 2, list())


class haxe_io_Output:
    _hx_class_name = "haxe.io.Output"
    __slots__ = ("bigEndian",)
    _hx_fields = ["bigEndian"]
    _hx_methods = ["writeByte", "writeBytes", "flush", "close", "set_bigEndian", "writeFullBytes", "writeString"]

    def writeByte(self,c):
        raise _HxException("Not implemented")

    def writeBytes(self,s,pos,_hx_len):
        if (((pos < 0) or ((_hx_len < 0))) or (((pos + _hx_len) > s.length))):
            raise _HxException(haxe_io_Error.OutsideBounds)
        b = s.b
        k = _hx_len
        while (k > 0):
            self.writeByte(b[pos])
            pos = (pos + 1)
            k = (k - 1)
        return _hx_len

    def flush(self):
        pass

    def close(self):
        pass

    def set_bigEndian(self,b):
        self.bigEndian = b
        return b

    def writeFullBytes(self,s,pos,_hx_len):
        while (_hx_len > 0):
            k = self.writeBytes(s,pos,_hx_len)
            pos = (pos + k)
            _hx_len = (_hx_len - k)

    def writeString(self,s):
        b = haxe_io_Bytes.ofString(s)
        self.writeFullBytes(b,0,b.length)



class python_Boot:
    _hx_class_name = "python.Boot"
    __slots__ = ()
    _hx_statics = ["keywords", "toString1", "fields", "simpleField", "field", "getInstanceFields", "getSuperClass", "getClassFields", "prefixLength", "unhandleKeywords"]

    @staticmethod
    def toString1(o,s):
        if (o is None):
            return "null"
        if isinstance(o,str):
            return o
        if (s is None):
            s = ""
        if (len(s) >= 5):
            return "<...>"
        if isinstance(o,bool):
            if o:
                return "true"
            else:
                return "false"
        if isinstance(o,int):
            return str(o)
        if isinstance(o,float):
            try:
                if (o == int(o)):
                    return str(Math.floor((o + 0.5)))
                else:
                    return str(o)
            except Exception as _hx_e:
                _hx_e1 = _hx_e.val if isinstance(_hx_e, _HxException) else _hx_e
                e = _hx_e1
                return str(o)
        if isinstance(o,list):
            o1 = o
            l = len(o1)
            st = "["
            s = (("null" if s is None else s) + "\t")
            _g1 = 0
            _g = l
            while (_g1 < _g):
                i = _g1
                _g1 = (_g1 + 1)
                prefix = ""
                if (i > 0):
                    prefix = ","
                st = (("null" if st is None else st) + HxOverrides.stringOrNull(((("null" if prefix is None else prefix) + HxOverrides.stringOrNull(python_Boot.toString1((o1[i] if i >= 0 and i < len(o1) else None),s))))))
            st = (("null" if st is None else st) + "]")
            return st
        try:
            if hasattr(o,"toString"):
                return o.toString()
        except Exception as _hx_e:
            _hx_e1 = _hx_e.val if isinstance(_hx_e, _HxException) else _hx_e
            pass
        if (python_lib_Inspect.isfunction(o) or python_lib_Inspect.ismethod(o)):
            return "<function>"
        if hasattr(o,"__class__"):
            if isinstance(o,_hx_AnonObject):
                toStr = None
                try:
                    fields = python_Boot.fields(o)
                    _g2 = []
                    _g11 = 0
                    while (_g11 < len(fields)):
                        f = (fields[_g11] if _g11 >= 0 and _g11 < len(fields) else None)
                        _g11 = (_g11 + 1)
                        x = ((("" + ("null" if f is None else f)) + " : ") + HxOverrides.stringOrNull(python_Boot.toString1(python_Boot.simpleField(o,f),(("null" if s is None else s) + "\t"))))
                        _g2.append(x)
                    fieldsStr = _g2
                    toStr = (("{ " + HxOverrides.stringOrNull(", ".join([x1 for x1 in fieldsStr]))) + " }")
                except Exception as _hx_e:
                    _hx_e1 = _hx_e.val if isinstance(_hx_e, _HxException) else _hx_e
                    e2 = _hx_e1
                    return "{ ... }"
                if (toStr is None):
                    return "{ ... }"
                else:
                    return toStr
            if isinstance(o,Enum):
                o2 = o
                l1 = len(o2.params)
                hasParams = (l1 > 0)
                if hasParams:
                    paramsStr = ""
                    _g12 = 0
                    _g3 = l1
                    while (_g12 < _g3):
                        i1 = _g12
                        _g12 = (_g12 + 1)
                        prefix1 = ""
                        if (i1 > 0):
                            prefix1 = ","
                        paramsStr = (("null" if paramsStr is None else paramsStr) + HxOverrides.stringOrNull(((("null" if prefix1 is None else prefix1) + HxOverrides.stringOrNull(python_Boot.toString1((o2.params[i1] if i1 >= 0 and i1 < len(o2.params) else None),s))))))
                    return (((HxOverrides.stringOrNull(o2.tag) + "(") + ("null" if paramsStr is None else paramsStr)) + ")")
                else:
                    return o2.tag
            if hasattr(o,"_hx_class_name"):
                if (o.__class__.__name__ != "type"):
                    fields1 = python_Boot.getInstanceFields(o)
                    _g4 = []
                    _g13 = 0
                    while (_g13 < len(fields1)):
                        f1 = (fields1[_g13] if _g13 >= 0 and _g13 < len(fields1) else None)
                        _g13 = (_g13 + 1)
                        x1 = ((("" + ("null" if f1 is None else f1)) + " : ") + HxOverrides.stringOrNull(python_Boot.toString1(python_Boot.simpleField(o,f1),(("null" if s is None else s) + "\t"))))
                        _g4.append(x1)
                    fieldsStr1 = _g4
                    toStr1 = (((HxOverrides.stringOrNull(o._hx_class_name) + "( ") + HxOverrides.stringOrNull(", ".join([x1 for x1 in fieldsStr1]))) + " )")
                    return toStr1
                else:
                    fields2 = python_Boot.getClassFields(o)
                    _g5 = []
                    _g14 = 0
                    while (_g14 < len(fields2)):
                        f2 = (fields2[_g14] if _g14 >= 0 and _g14 < len(fields2) else None)
                        _g14 = (_g14 + 1)
                        x2 = ((("" + ("null" if f2 is None else f2)) + " : ") + HxOverrides.stringOrNull(python_Boot.toString1(python_Boot.simpleField(o,f2),(("null" if s is None else s) + "\t"))))
                        _g5.append(x2)
                    fieldsStr2 = _g5
                    toStr2 = (((("#" + HxOverrides.stringOrNull(o._hx_class_name)) + "( ") + HxOverrides.stringOrNull(", ".join([x1 for x1 in fieldsStr2]))) + " )")
                    return toStr2
            if (o == str):
                return "#String"
            if (o == list):
                return "#Array"
            if callable(o):
                return "function"
            try:
                if hasattr(o,"__repr__"):
                    return o.__repr__()
            except Exception as _hx_e:
                _hx_e1 = _hx_e.val if isinstance(_hx_e, _HxException) else _hx_e
                pass
            if hasattr(o,"__str__"):
                return o.__str__([])
            if hasattr(o,"__name__"):
                return o.__name__
            return "???"
        else:
            return str(o)

    @staticmethod
    def fields(o):
        a = []
        if (o is not None):
            if hasattr(o,"_hx_fields"):
                fields = o._hx_fields
                return list(fields)
            if isinstance(o,_hx_AnonObject):
                d = o.__dict__
                keys = d.keys()
                handler = python_Boot.unhandleKeywords
                for k in keys:
                    a.append(handler(k))
            elif hasattr(o,"__dict__"):
                d1 = o.__dict__
                keys1 = d1.keys()
                for k in keys1:
                    a.append(k)
        return a

    @staticmethod
    def simpleField(o,field):
        if (field is None):
            return None
        field1 = (("_hx_" + field) if ((field in python_Boot.keywords)) else (("_hx_" + field) if (((((len(field) > 2) and ((ord(field[0]) == 95))) and ((ord(field[1]) == 95))) and ((ord(field[(len(field) - 1)]) != 95)))) else field))
        if hasattr(o,field1):
            return getattr(o,field1)
        else:
            return None

    @staticmethod
    def field(o,field):
        if (field is None):
            return None
        field1 = field
        _hx_local_0 = len(field1)
        if (_hx_local_0 == 10):
            if (field1 == "charCodeAt"):
                if isinstance(o,str):
                    s1 = o
                    def _hx_local_1(a11):
                        return HxString.charCodeAt(s1,a11)
                    return _hx_local_1
        elif (_hx_local_0 == 11):
            if (field1 == "lastIndexOf"):
                if isinstance(o,str):
                    s3 = o
                    def _hx_local_2(a15):
                        return HxString.lastIndexOf(s3,a15)
                    return _hx_local_2
                elif isinstance(o,list):
                    a4 = o
                    def _hx_local_3(x4):
                        return python_internal_ArrayImpl.lastIndexOf(a4,x4)
                    return _hx_local_3
            elif (field1 == "toLowerCase"):
                if isinstance(o,str):
                    s7 = o
                    def _hx_local_4():
                        return HxString.toLowerCase(s7)
                    return _hx_local_4
            elif (field1 == "toUpperCase"):
                if isinstance(o,str):
                    s9 = o
                    def _hx_local_5():
                        return HxString.toUpperCase(s9)
                    return _hx_local_5
        elif (_hx_local_0 == 9):
            if (field1 == "substring"):
                if isinstance(o,str):
                    s6 = o
                    def _hx_local_6(a19):
                        return HxString.substring(s6,a19)
                    return _hx_local_6
        elif (_hx_local_0 == 4):
            if (field1 == "copy"):
                if isinstance(o,list):
                    def _hx_local_7():
                        return list(o)
                    return _hx_local_7
            elif (field1 == "join"):
                if isinstance(o,list):
                    def _hx_local_8(sep):
                        return sep.join([python_Boot.toString1(x1,'') for x1 in o])
                    return _hx_local_8
            elif (field1 == "push"):
                if isinstance(o,list):
                    x7 = o
                    def _hx_local_9(e):
                        return python_internal_ArrayImpl.push(x7,e)
                    return _hx_local_9
            elif (field1 == "sort"):
                if isinstance(o,list):
                    x11 = o
                    def _hx_local_10(f2):
                        python_internal_ArrayImpl.sort(x11,f2)
                    return _hx_local_10
        elif (_hx_local_0 == 5):
            if (field1 == "shift"):
                if isinstance(o,list):
                    x9 = o
                    def _hx_local_11():
                        return python_internal_ArrayImpl.shift(x9)
                    return _hx_local_11
            elif (field1 == "slice"):
                if isinstance(o,list):
                    x10 = o
                    def _hx_local_12(a16):
                        return python_internal_ArrayImpl.slice(x10,a16)
                    return _hx_local_12
            elif (field1 == "split"):
                if isinstance(o,str):
                    s4 = o
                    def _hx_local_13(d):
                        return HxString.split(s4,d)
                    return _hx_local_13
        elif (_hx_local_0 == 7):
            if (field1 == "indexOf"):
                if isinstance(o,str):
                    s2 = o
                    def _hx_local_14(a13):
                        return HxString.indexOf(s2,a13)
                    return _hx_local_14
                elif isinstance(o,list):
                    a = o
                    def _hx_local_15(x1):
                        return python_internal_ArrayImpl.indexOf(a,x1)
                    return _hx_local_15
            elif (field1 == "reverse"):
                if isinstance(o,list):
                    a5 = o
                    def _hx_local_16():
                        python_internal_ArrayImpl.reverse(a5)
                    return _hx_local_16
            elif (field1 == "unshift"):
                if isinstance(o,list):
                    x14 = o
                    def _hx_local_17(e2):
                        python_internal_ArrayImpl.unshift(x14,e2)
                    return _hx_local_17
        elif (_hx_local_0 == 3):
            if (field1 == "map"):
                if isinstance(o,list):
                    x5 = o
                    def _hx_local_18(f1):
                        return python_internal_ArrayImpl.map(x5,f1)
                    return _hx_local_18
            elif (field1 == "pop"):
                if isinstance(o,list):
                    x6 = o
                    def _hx_local_19():
                        return python_internal_ArrayImpl.pop(x6)
                    return _hx_local_19
        elif (_hx_local_0 == 8):
            if (field1 == "iterator"):
                if isinstance(o,list):
                    x3 = o
                    def _hx_local_20():
                        return python_internal_ArrayImpl.iterator(x3)
                    return _hx_local_20
            elif (field1 == "toString"):
                if isinstance(o,str):
                    s8 = o
                    def _hx_local_21():
                        return HxString.toString(s8)
                    return _hx_local_21
                elif isinstance(o,list):
                    x13 = o
                    def _hx_local_22():
                        return python_internal_ArrayImpl.toString(x13)
                    return _hx_local_22
        elif (_hx_local_0 == 6):
            if (field1 == "charAt"):
                if isinstance(o,str):
                    s = o
                    def _hx_local_23(a1):
                        return HxString.charAt(s,a1)
                    return _hx_local_23
            elif (field1 == "concat"):
                if isinstance(o,list):
                    a12 = o
                    def _hx_local_24(a2):
                        return python_internal_ArrayImpl.concat(a12,a2)
                    return _hx_local_24
            elif (field1 == "filter"):
                if isinstance(o,list):
                    x = o
                    def _hx_local_25(f):
                        return python_internal_ArrayImpl.filter(x,f)
                    return _hx_local_25
            elif (field1 == "insert"):
                if isinstance(o,list):
                    a3 = o
                    def _hx_local_26(a14,x2):
                        python_internal_ArrayImpl.insert(a3,a14,x2)
                    return _hx_local_26
            elif (field1 == "length"):
                if isinstance(o,str):
                    return len(o)
                elif isinstance(o,list):
                    return len(o)
            elif (field1 == "remove"):
                if isinstance(o,list):
                    x8 = o
                    def _hx_local_27(e1):
                        return python_internal_ArrayImpl.remove(x8,e1)
                    return _hx_local_27
            elif (field1 == "splice"):
                if isinstance(o,list):
                    x12 = o
                    def _hx_local_28(a17,a21):
                        return python_internal_ArrayImpl.splice(x12,a17,a21)
                    return _hx_local_28
            elif (field1 == "substr"):
                if isinstance(o,str):
                    s5 = o
                    def _hx_local_29(a18):
                        return HxString.substr(s5,a18)
                    return _hx_local_29
        else:
            pass
        field2 = (("_hx_" + field) if ((field in python_Boot.keywords)) else (("_hx_" + field) if (((((len(field) > 2) and ((ord(field[0]) == 95))) and ((ord(field[1]) == 95))) and ((ord(field[(len(field) - 1)]) != 95)))) else field))
        if hasattr(o,field2):
            return getattr(o,field2)
        else:
            return None

    @staticmethod
    def getInstanceFields(c):
        f = (c._hx_fields if (hasattr(c,"_hx_fields")) else [])
        if hasattr(c,"_hx_methods"):
            f = (f + c._hx_methods)
        sc = python_Boot.getSuperClass(c)
        if (sc is None):
            return f
        else:
            scArr = python_Boot.getInstanceFields(sc)
            scMap = set(scArr)
            _g = 0
            while (_g < len(f)):
                f1 = (f[_g] if _g >= 0 and _g < len(f) else None)
                _g = (_g + 1)
                if (not (f1 in scMap)):
                    scArr.append(f1)
            return scArr

    @staticmethod
    def getSuperClass(c):
        if (c is None):
            return None
        try:
            if hasattr(c,"_hx_super"):
                return c._hx_super
            return None
        except Exception as _hx_e:
            _hx_e1 = _hx_e.val if isinstance(_hx_e, _HxException) else _hx_e
            pass
        return None

    @staticmethod
    def getClassFields(c):
        if hasattr(c,"_hx_statics"):
            x = c._hx_statics
            return list(x)
        else:
            return []

    @staticmethod
    def unhandleKeywords(name):
        if (HxString.substr(name,0,python_Boot.prefixLength) == "_hx_"):
            real = HxString.substr(name,python_Boot.prefixLength,None)
            if (real in python_Boot.keywords):
                return real
        return name


class python__KwArgs_KwArgs_Impl_:
    _hx_class_name = "python._KwArgs.KwArgs_Impl_"
    __slots__ = ()
    _hx_statics = ["fromT"]

    @staticmethod
    def fromT(d):
        this1 = python_Lib.anonAsDict(d)
        return this1


class python_Lib:
    _hx_class_name = "python.Lib"
    __slots__ = ()
    _hx_statics = ["print", "println", "anonToDict", "anonAsDict", "dictAsAnon"]

    @staticmethod
    def print(v):
        _hx_str = Std.string(v)
        python_lib_Sys.stdout.buffer.write(_hx_str.encode("utf-8", "strict"))
        python_lib_Sys.stdout.flush()

    @staticmethod
    def println(v):
        _hx_str = Std.string(v)
        python_lib_Sys.stdout.buffer.write((("" + ("null" if _hx_str is None else _hx_str)) + "\n").encode("utf-8", "strict"))
        python_lib_Sys.stdout.flush()

    @staticmethod
    def anonToDict(o):
        if isinstance(o,_hx_AnonObject):
            return o.__dict__.copy()
        else:
            return None

    @staticmethod
    def anonAsDict(o):
        if isinstance(o,_hx_AnonObject):
            return o.__dict__
        else:
            return None

    @staticmethod
    def dictAsAnon(d):
        return _hx_AnonObject(d)


class python_internal_ArrayImpl:
    _hx_class_name = "python.internal.ArrayImpl"
    __slots__ = ()
    _hx_statics = ["concat", "iterator", "indexOf", "lastIndexOf", "toString", "pop", "push", "unshift", "remove", "shift", "slice", "sort", "splice", "map", "filter", "insert", "reverse", "_get"]

    @staticmethod
    def concat(a1,a2):
        return (a1 + a2)

    @staticmethod
    def iterator(x):
        return python_HaxeIterator(x.__iter__())

    @staticmethod
    def indexOf(a,x,fromIndex = None):
        _hx_len = len(a)
        l = (0 if ((fromIndex is None)) else ((_hx_len + fromIndex) if ((fromIndex < 0)) else fromIndex))
        if (l < 0):
            l = 0
        _g1 = l
        _g = _hx_len
        while (_g1 < _g):
            i = _g1
            _g1 = (_g1 + 1)
            if (a[i] == x):
                return i
        return -1

    @staticmethod
    def lastIndexOf(a,x,fromIndex = None):
        _hx_len = len(a)
        l = (_hx_len if ((fromIndex is None)) else (((_hx_len + fromIndex) + 1) if ((fromIndex < 0)) else (fromIndex + 1)))
        if (l > _hx_len):
            l = _hx_len
        while True:
            l = (l - 1)
            tmp = l
            if (not ((tmp > -1))):
                break
            if (a[l] == x):
                return l
        return -1

    @staticmethod
    def toString(x):
        return (("[" + HxOverrides.stringOrNull(",".join([python_Boot.toString1(x1,'') for x1 in x]))) + "]")

    @staticmethod
    def pop(x):
        if (len(x) == 0):
            return None
        else:
            return x.pop()

    @staticmethod
    def push(x,e):
        x.append(e)
        return len(x)

    @staticmethod
    def unshift(x,e):
        x.insert(0, e)

    @staticmethod
    def remove(x,e):
        try:
            x.remove(e)
            return True
        except Exception as _hx_e:
            _hx_e1 = _hx_e.val if isinstance(_hx_e, _HxException) else _hx_e
            e1 = _hx_e1
            return False

    @staticmethod
    def shift(x):
        if (len(x) == 0):
            return None
        return x.pop(0)

    @staticmethod
    def slice(x,pos,end = None):
        return x[pos:end]

    @staticmethod
    def sort(x,f):
        x.sort(key= python_lib_Functools.cmp_to_key(f))

    @staticmethod
    def splice(x,pos,_hx_len):
        if (pos < 0):
            pos = (len(x) + pos)
        if (pos < 0):
            pos = 0
        res = x[pos:(pos + _hx_len)]
        del x[pos:(pos + _hx_len)]
        return res

    @staticmethod
    def map(x,f):
        return list(map(f,x))

    @staticmethod
    def filter(x,f):
        return list(filter(f,x))

    @staticmethod
    def insert(a,pos,x):
        a.insert(pos, x)

    @staticmethod
    def reverse(a):
        a.reverse()

    @staticmethod
    def _get(x,idx):
        if ((idx > -1) and ((idx < len(x)))):
            return x[idx]
        else:
            return None


class _HxException(Exception):
    _hx_class_name = "_HxException"
    __slots__ = ("val",)
    _hx_fields = ["val"]
    _hx_methods = []
    _hx_statics = []
    _hx_interfaces = []
    _hx_super = Exception


    def __init__(self,val):
        self.val = None
        message = str(val)
        super().__init__(message)
        self.val = val



class HxOverrides:
    _hx_class_name = "HxOverrides"
    __slots__ = ()
    _hx_statics = ["eq", "stringOrNull", "modf", "mod", "arrayGet", "mapKwArgs"]

    @staticmethod
    def eq(a,b):
        if (isinstance(a,list) or isinstance(b,list)):
            return a is b
        return (a == b)

    @staticmethod
    def stringOrNull(s):
        if (s is None):
            return "null"
        else:
            return s

    @staticmethod
    def modf(a,b):
        return float('nan') if (b == 0.0) else a % b if a >= 0 else -(-a % b)

    @staticmethod
    def mod(a,b):
        return a % b if a >= 0 else -(-a % b)

    @staticmethod
    def arrayGet(a,i):
        if isinstance(a,list):
            x = a
            if ((i > -1) and ((i < len(x)))):
                return x[i]
            else:
                return None
        else:
            return a[i]

    @staticmethod
    def mapKwArgs(a,v):
        a1 = python_Lib.dictAsAnon(python_Lib.anonToDict(a))
        k = python_HaxeIterator(iter(v.keys()))
        while k.hasNext():
            k1 = k.next()
            val = v.get(k1)
            if hasattr(a1,k1):
                x = getattr(a1,k1)
                setattr(a1,val,x)
                delattr(a1,k1)
        return a1


class HxString:
    _hx_class_name = "HxString"
    __slots__ = ()
    _hx_statics = ["split", "charCodeAt", "charAt", "lastIndexOf", "toUpperCase", "toLowerCase", "indexOf", "toString", "substring", "substr"]

    @staticmethod
    def split(s,d):
        if (d == ""):
            return list(s)
        else:
            return s.split(d)

    @staticmethod
    def charCodeAt(s,index):
        if ((((s is None) or ((len(s) == 0))) or ((index < 0))) or ((index >= len(s)))):
            return None
        else:
            return ord(s[index])

    @staticmethod
    def charAt(s,index):
        if ((index < 0) or ((index >= len(s)))):
            return ""
        else:
            return s[index]

    @staticmethod
    def lastIndexOf(s,_hx_str,startIndex = None):
        if (startIndex is None):
            return s.rfind(_hx_str, 0, len(s))
        else:
            i = s.rfind(_hx_str, 0, (startIndex + 1))
            startLeft = (max(0,((startIndex + 1) - len(_hx_str))) if ((i == -1)) else (i + 1))
            check = s.find(_hx_str, startLeft, len(s))
            if ((check > i) and ((check <= startIndex))):
                return check
            else:
                return i

    @staticmethod
    def toUpperCase(s):
        return s.upper()

    @staticmethod
    def toLowerCase(s):
        return s.lower()

    @staticmethod
    def indexOf(s,_hx_str,startIndex = None):
        if (startIndex is None):
            return s.find(_hx_str)
        else:
            return s.find(_hx_str, startIndex)

    @staticmethod
    def toString(s):
        return s

    @staticmethod
    def substring(s,startIndex,endIndex = None):
        if (startIndex < 0):
            startIndex = 0
        if (endIndex is None):
            return s[startIndex:]
        else:
            if (endIndex < 0):
                endIndex = 0
            if (endIndex < startIndex):
                return s[endIndex:startIndex]
            else:
                return s[startIndex:endIndex]

    @staticmethod
    def substr(s,startIndex,_hx_len = None):
        if (_hx_len is None):
            return s[startIndex:]
        else:
            if (_hx_len == 0):
                return ""
            return s[startIndex:(startIndex + _hx_len)]


class python_io_NativeInput(haxe_io_Input):
    _hx_class_name = "python.io.NativeInput"
    __slots__ = ("stream", "wasEof")
    _hx_fields = ["stream", "wasEof"]
    _hx_methods = ["throwEof", "readinto", "readBytes"]
    _hx_statics = []
    _hx_interfaces = []
    _hx_super = haxe_io_Input


    def __init__(self,s):
        self.wasEof = None
        self.stream = s
        self.set_bigEndian(False)
        self.wasEof = False
        if (not self.stream.readable()):
            raise _HxException("Write-only stream")

    def throwEof(self):
        self.wasEof = True
        raise _HxException(haxe_io_Eof())

    def readinto(self,b):
        raise _HxException("abstract method, should be overriden")

    def readBytes(self,s,pos,_hx_len):
        if (((pos < 0) or ((_hx_len < 0))) or (((pos + _hx_len) > s.length))):
            raise _HxException(haxe_io_Error.OutsideBounds)
        ba = bytearray(_hx_len)
        ret = self.readinto(ba)
        if (ret == 0):
            self.throwEof()
        s.blit(pos,haxe_io_Bytes.ofData(ba),0,_hx_len)
        return ret



class python_io_IInput:
    _hx_class_name = "python.io.IInput"
    __slots__ = ()
    _hx_methods = ["set_bigEndian", "readByte", "readBytes", "readAll"]


class python_io_NativeBytesInput(python_io_NativeInput):
    _hx_class_name = "python.io.NativeBytesInput"
    __slots__ = ()
    _hx_fields = []
    _hx_methods = ["readByte", "readinto"]
    _hx_statics = []
    _hx_interfaces = [python_io_IInput]
    _hx_super = python_io_NativeInput


    def __init__(self,stream):
        super().__init__(stream)

    def readByte(self):
        ret = self.stream.read(1)
        if (len(ret) == 0):
            self.throwEof()
        return ret[0]

    def readinto(self,b):
        return self.stream.readinto(b)



class python_io_IFileInput:
    _hx_class_name = "python.io.IFileInput"
    __slots__ = ()
    _hx_interfaces = [python_io_IInput]


class python_io_FileBytesInput(python_io_NativeBytesInput):
    _hx_class_name = "python.io.FileBytesInput"
    __slots__ = ()
    _hx_fields = []
    _hx_methods = []
    _hx_statics = []
    _hx_interfaces = [python_io_IFileInput]
    _hx_super = python_io_NativeBytesInput


    def __init__(self,stream):
        super().__init__(stream)


class python_io_NativeOutput(haxe_io_Output):
    _hx_class_name = "python.io.NativeOutput"
    __slots__ = ("stream",)
    _hx_fields = ["stream"]
    _hx_methods = ["close", "flush"]
    _hx_statics = []
    _hx_interfaces = []
    _hx_super = haxe_io_Output


    def __init__(self,stream):
        self.stream = None
        self.set_bigEndian(False)
        self.stream = stream
        if (not stream.writable()):
            raise _HxException("Read only stream")

    def close(self):
        self.stream.close()

    def flush(self):
        self.stream.flush()



class python_io_IOutput:
    _hx_class_name = "python.io.IOutput"
    __slots__ = ()
    _hx_methods = ["set_bigEndian", "writeByte", "writeBytes", "flush", "close", "writeFullBytes", "writeString"]


class python_io_IFileOutput:
    _hx_class_name = "python.io.IFileOutput"
    __slots__ = ()
    _hx_interfaces = [python_io_IOutput]


class python_io_NativeTextInput(python_io_NativeInput):
    _hx_class_name = "python.io.NativeTextInput"
    __slots__ = ()
    _hx_fields = []
    _hx_methods = ["readByte", "readinto"]
    _hx_statics = []
    _hx_interfaces = [python_io_IInput]
    _hx_super = python_io_NativeInput


    def __init__(self,stream):
        super().__init__(stream)

    def readByte(self):
        ret = self.stream.read(1)
        if (len(ret) == 0):
            self.throwEof()
        return HxString.charCodeAt(ret,0)

    def readinto(self,b):
        return self.stream.buffer.readinto(b)



class python_io_FileTextInput(python_io_NativeTextInput):
    _hx_class_name = "python.io.FileTextInput"
    __slots__ = ()
    _hx_fields = []
    _hx_methods = []
    _hx_statics = []
    _hx_interfaces = [python_io_IFileInput]
    _hx_super = python_io_NativeTextInput


    def __init__(self,stream):
        super().__init__(stream)


class python_io_NativeTextOutput(python_io_NativeOutput):
    _hx_class_name = "python.io.NativeTextOutput"
    __slots__ = ()
    _hx_fields = []
    _hx_methods = ["writeByte"]
    _hx_statics = []
    _hx_interfaces = []
    _hx_super = python_io_NativeOutput


    def __init__(self,stream):
        super().__init__(stream)
        if (not stream.writable()):
            raise _HxException("Read only stream")

    def writeByte(self,c):
        self.stream.write("".join(map(chr,[c])))



class python_io_FileTextOutput(python_io_NativeTextOutput):
    _hx_class_name = "python.io.FileTextOutput"
    __slots__ = ()
    _hx_fields = []
    _hx_methods = []
    _hx_statics = []
    _hx_interfaces = [python_io_IFileOutput]
    _hx_super = python_io_NativeTextOutput


    def __init__(self,stream):
        super().__init__(stream)


class python_io_IoTools:
    _hx_class_name = "python.io.IoTools"
    __slots__ = ()
    _hx_statics = ["createFileInputFromText", "createFileInputFromBytes", "createFileOutputFromText"]

    @staticmethod
    def createFileInputFromText(t):
        return sys_io_FileInput(python_io_FileTextInput(t))

    @staticmethod
    def createFileInputFromBytes(t):
        return sys_io_FileInput(python_io_FileBytesInput(t))

    @staticmethod
    def createFileOutputFromText(t):
        return sys_io_FileOutput(python_io_FileTextOutput(t))


class sys_io_File:
    _hx_class_name = "sys.io.File"
    __slots__ = ()
    _hx_statics = ["saveBytes", "read"]

    @staticmethod
    def saveBytes(path,_hx_bytes):
        f = python_lib_Builtins.open(path,"wb",-1)
        f.write(_hx_bytes.b)
        f.close()

    @staticmethod
    def read(path,binary = True):
        if (binary is None):
            binary = True
        mode = ("rb" if binary else "r")
        f = python_lib_Builtins.open(path,mode,-1,None,None,(None if binary else ""))
        if binary:
            return python_io_IoTools.createFileInputFromBytes(f)
        else:
            return python_io_IoTools.createFileInputFromText(f)


class sys_io_FileInput(haxe_io_Input):
    _hx_class_name = "sys.io.FileInput"
    __slots__ = ("impl",)
    _hx_fields = ["impl"]
    _hx_methods = ["set_bigEndian", "readByte", "readBytes", "readAll"]
    _hx_statics = []
    _hx_interfaces = []
    _hx_super = haxe_io_Input


    def __init__(self,impl):
        self.impl = impl

    def set_bigEndian(self,b):
        return self.impl.set_bigEndian(b)

    def readByte(self):
        return self.impl.readByte()

    def readBytes(self,s,pos,_hx_len):
        return self.impl.readBytes(s,pos,_hx_len)

    def readAll(self,bufsize = None):
        return self.impl.readAll(bufsize)



class sys_io_FileOutput(haxe_io_Output):
    _hx_class_name = "sys.io.FileOutput"
    __slots__ = ("impl",)
    _hx_fields = ["impl"]
    _hx_methods = ["set_bigEndian", "writeByte", "writeBytes", "flush", "close", "writeFullBytes", "writeString"]
    _hx_statics = []
    _hx_interfaces = []
    _hx_super = haxe_io_Output


    def __init__(self,impl):
        self.impl = impl

    def set_bigEndian(self,b):
        return self.impl.set_bigEndian(b)

    def writeByte(self,c):
        self.impl.writeByte(c)

    def writeBytes(self,s,pos,_hx_len):
        return self.impl.writeBytes(s,pos,_hx_len)

    def flush(self):
        self.impl.flush()

    def close(self):
        self.impl.close()

    def writeFullBytes(self,s,pos,_hx_len):
        self.impl.writeFullBytes(s,pos,_hx_len)

    def writeString(self,s):
        self.impl.writeString(s)


Math.NEGATIVE_INFINITY = float("-inf")
Math.POSITIVE_INFINITY = float("inf")
Math.NaN = float("nan")
Math.PI = python_lib_Math.pi

def _hx_init_Sys_environ():
    def _hx_local_0():
        Sys.environ = haxe_ds_StringMap()
        env = python_lib_Os.environ
        key = python_HaxeIterator(iter(env.keys()))
        while key.hasNext():
            key1 = key.next()
            _this = Sys.environ
            value = env.get(key1,None)
            _this.h[key1] = value
        return Sys.environ
    return _hx_local_0()
Sys.environ = _hx_init_Sys_environ()
Sys._programPath = sys_FileSystem.fullPath(python_lib_Inspect.getsourcefile(Sys))
python_Boot.keywords = set(["and", "del", "from", "not", "with", "as", "elif", "global", "or", "yield", "assert", "else", "if", "pass", "None", "break", "except", "import", "raise", "True", "class", "exec", "in", "return", "False", "continue", "finally", "is", "try", "def", "for", "lambda", "while"])
python_Boot.prefixLength = len("_hx_")

MBF.main()